home *** CD-ROM | disk | FTP | other *** search
/ PC World 2006 February / PCWorld_2006-02_cd.bin / software / vyzkuste / triky / triky.exe / httrack-3.33.exe / {app} / src / htslib.c < prev    next >
C/C++ Source or Header  |  2005-02-05  |  139KB  |  5,019 lines
  1. /* ------------------------------------------------------------ */
  2. /*
  3. HTTrack Website Copier, Offline Browser for Windows and Unix
  4. Copyright (C) Xavier Roche and other contributors
  5.  
  6. This program is free software; you can redistribute it and/or
  7. modify it under the terms of the GNU General Public License
  8. as published by the Free Software Foundation; either version 2
  9. of the License, or any later version.
  10.  
  11. This program is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. GNU General Public License for more details.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with this program; if not, write to the Free Software
  18. Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  19.  
  20.  
  21. Important notes:
  22.  
  23. - We hereby ask people using this source NOT to use it in purpose of grabbing
  24. emails addresses, or collecting any other private information on persons.
  25. This would disgrace our work, and spoil the many hours we spent on it.
  26.  
  27.  
  28. Please visit our Website: http://www.httrack.com
  29. */
  30.  
  31.  
  32. /* ------------------------------------------------------------ */
  33. /* File: Subroutines                                            */
  34. /* Author: Xavier Roche                                         */
  35. /* ------------------------------------------------------------ */
  36.  
  37. /* Internal engine bytecode */
  38. #define HTS_INTERNAL_BYTECODE
  39.  
  40. // Fichier librairie .c
  41.  
  42. #include "htslib.h"
  43. #include "htsbauth.h"
  44.  
  45. #ifdef _WIN32_WCE
  46. #ifndef HTS_CECOMPAT
  47. #pragma comment(lib, "celib.lib") //link with celib
  48. #endif
  49. #endif
  50.  
  51. /* specific definitions */
  52. #include "htsbase.h"
  53. #include "htsnet.h"
  54. #include "htsbauth.h"
  55. #include "htsthread.h"
  56. #include "htsnostatic.h"
  57. #include "htswrap.h"
  58. #include "htsmd5.h"
  59. #if HTS_WIN
  60. #ifndef  _WIN32_WCE
  61. #include <direct.h>
  62. #endif
  63. #else
  64. #ifdef HAVE_SYS_TYPES_H
  65. #include <sys/types.h>
  66. #endif
  67. #ifdef HAVE_SYS_STAT_H
  68. #include <sys/stat.h>
  69. #endif
  70. #ifdef HAVE_UNISTD_H
  71. #include <unistd.h>
  72. #endif
  73. #endif
  74. #include <string.h>
  75. #include <time.h>
  76. #ifndef  _WIN32_WCE
  77. #include <sys/timeb.h>
  78. #else
  79. #ifndef HTS_CECOMPAT
  80. #include <sys/timeb.h>
  81. #endif
  82. #endif
  83. #ifndef _WIN32_WCE
  84. #include <fcntl.h>
  85. #endif
  86. // pour utimbuf
  87. #if HTS_WIN
  88. #ifndef _WIN32_WCE
  89. #include <sys/utime.h>
  90. #else
  91. #ifndef HTS_CECOMPAT
  92. #include <sys/utime.h>
  93. #endif
  94. #endif
  95. #else
  96. #include <utime.h>
  97. #endif
  98. #ifndef _WIN32_WCE
  99. #include <sys/stat.h>
  100. #endif
  101. /* END specific definitions */
  102.  
  103.  
  104. // Debugging
  105. #if _HTS_WIDE
  106. FILE* DEBUG_fp=NULL;
  107. #endif
  108.  
  109. /* variables globales */
  110. int _DEBUG_HEAD;
  111. FILE* ioinfo;
  112.  
  113. #if HTS_USEOPENSSL
  114.  SSL_CTX *openssl_ctx = NULL;
  115. #endif
  116. int IPV6_resolver = 0;
  117.  
  118.  
  119. /* dΘtection complΘmentaire */
  120. const char* hts_detect[] = {
  121.   "archive",
  122.   "background",
  123.   "data",         // OBJECT
  124.   "dynsrc",
  125.   "lowsrc",
  126.   "profile",      // element META
  127.   "src",
  128.   "swurl",
  129.   "url",
  130.   "usemap",
  131.   "longdesc",     // accessibility
  132.   "xlink:href",   // xml/svg tag
  133.   ""
  134. };
  135.  
  136. /* dΘtecter dΘbut */
  137. const char* hts_detectbeg[] = {
  138.   "hotspot",      /* hotspot1=..,hotspot2=.. */
  139.   ""
  140. };
  141.  
  142. /* ne pas dΘtcter de liens dedans */
  143. const char* hts_nodetect[] = {
  144.   "accept-charset",
  145.   "accesskey",
  146.   "action",
  147.   "align",
  148.   "alt",
  149.   "axes",
  150.   "axis",
  151.   "char",
  152.   "charset",
  153.   "cite",
  154.   "class",
  155.   "classid",
  156.   "code",
  157.   "color",
  158.   "datetime",
  159.   "dir",
  160.   "enctype",
  161.   "face",
  162.   "height",
  163.   "id",
  164.   "lang",
  165.   "language",
  166.   "media",
  167.   "method",
  168.   "name",
  169.   "prompt",
  170.   "scheme",
  171.   "size",
  172.   "style",
  173.   "target",
  174.   "title",
  175.   "type",
  176.   "valign",
  177.   "version",
  178.   "width",
  179.   ""
  180. };
  181.  
  182.  
  183. /* dΘtection de mini-code javascript */
  184. /* ALSO USED: detection based on the name: onXXX="<tag>" where XXX starts with upper case letter */
  185. const char* hts_detect_js[] = {
  186.   "onAbort",
  187.   "onBlur",
  188.   "onChange",
  189.   "onClick",
  190.   "onDblClick",
  191.   "onDragDrop",
  192.   "onError",
  193.   "onFocus",
  194.   "onKeyDown",
  195.   "onKeyPress",
  196.   "onKeyUp",
  197.   "onLoad",
  198.   "onMouseDown",
  199.   "onMouseMove",
  200.   "onMouseOut",
  201.   "onMouseOver",
  202.   "onMouseUp",
  203.   "onMove",
  204.   "onReset",
  205.   "onResize",
  206.   "onSelect",
  207.   "onSubmit",
  208.   "onUnload",
  209.   "style",          /* hack for CSS code data */
  210.   ""
  211. };
  212.  
  213. const char* hts_main_mime[] = {
  214.   "application",
  215.   "audio",
  216.   "image",
  217.   "message",
  218.   "multipart",
  219.   "text",
  220.   "video",
  221.   ""
  222. };
  223.  
  224. /* dΘtection "...URL=<url>" */
  225. const char* hts_detectURL[] = {
  226.   "content",
  227.   ""
  228. };
  229.  
  230. /* tags o∙ l'URL doit Ωtre rΘΘcrite mais non capturΘe */
  231. const char* hts_detectandleave[] = {
  232.   "action",
  233.   ""
  234. };
  235.  
  236. /* ne pas renommer les types renvoyΘs (souvent types inconnus) */
  237. const char* hts_mime_keep[] = {
  238.   "application/octet-stream",
  239.   "text/plain",
  240.   ""
  241. };
  242.  
  243. /* pas de type mime connu, mais extension connue */
  244. const char* hts_ext_dynamic[] = {
  245.   "php3",
  246.   "php",
  247.   "php4",
  248.   "php2",
  249.   "cgi",
  250.   "asp",
  251.   "jsp",
  252.   "pl",
  253.   /*"exe",*/
  254.   "cfm",
  255.   "nsf", /* lotus */
  256.   ""
  257. };
  258.  
  259. /* types MIME 
  260.    note: application/octet-stream should not be used here
  261. */
  262. const char* hts_mime[][2] = {
  263.   {"application/acad","dwg"},
  264.   {"application/arj","arj"},
  265.   {"application/clariscad","ccad"},
  266.   {"application/drafting","drw"},
  267.   {"application/dxf","dxf"},
  268.   {"application/excel","xls"},
  269.   {"application/i-deas","unv"},
  270.   {"application/iges","isg"},
  271.   {"application/iges","iges"},
  272.   {"application/mac-binhex40","hqx"},
  273.   {"application/mac-compactpro","cpt"},
  274.   {"application/msword","doc"},
  275.   {"application/msword","w6w"},
  276.   {"application/msword","word"},
  277.   {"application/mswrite","wri"},
  278.   /*{"application/octet-stream","dms"},*/
  279.   /*{"application/octet-stream","lzh"},*/
  280.   /*{"application/octet-stream","lha"},*/
  281.   /*{"application/octet-stream","bin"},*/
  282.   {"application/oda","oda"},
  283.   {"application/pdf","pdf"},
  284.   {"application/postscript","ps"},
  285.   {"application/postscript","ai"},
  286.   {"application/postscript","eps"},
  287.   {"application/powerpoint","ppt"},
  288.   {"application/pro_eng","prt"},
  289.   {"application/pro_eng","part"},
  290.   {"application/rtf","rtf"},
  291.   {"application/set","set"},
  292.   {"application/sla","stl"},
  293.   {"application/smil","smi"},
  294.   {"application/smil","smil"},
  295.   {"application/smil","sml"},
  296.   {"application/solids","sol"},
  297.   {"application/STEP","stp"},
  298.   {"application/STEP","step"},
  299.   {"application/vda","vda"},
  300.   {"application/x-authorware-map","aam"},     
  301.   {"application/x-authorware-seg","aas"},
  302.   {"application/x-authorware-bin","aab"},
  303.   {"application/x-cocoa","cco"},
  304.   {"application/x-csh","csh"},
  305.   {"application/x-director","dir"},
  306.   {"application/x-director","dcr"},
  307.   {"application/x-director","dxr"},
  308.   {"application/x-mif","mif"},
  309.   {"application/x-dvi","dvi"},
  310.   {"application/x-gzip","gz"},
  311.   {"application/x-gzip","gzip"},
  312.   {"application/x-hdf","hdf"},
  313.   {"application/x-javascript","js"},
  314.   {"application/x-koan","skp"},
  315.   {"application/x-koan","skd"},
  316.   {"application/x-koan","skt"},
  317.   {"application/x-koan","skm"},
  318.   {"application/x-latex","latex"},
  319.   {"application/x-netcdf","nc"},
  320.   {"application/x-netcdf","cdf"},
  321.   /* {"application/x-sh","sh"}, */
  322.   /* {"application/x-csh","csh"}, */
  323.   /* {"application/x-ksh","ksh"}, */
  324.   {"application/x-shar","shar"},
  325.   {"application/x-stuffit","sit"},
  326.   {"application/x-tcl","tcl"},
  327.   {"application/x-tex","tex"},
  328.   {"application/x-texinfo","texinfo"},
  329.   {"application/x-texinfo","texi"},
  330.   {"application/x-troff","t"},
  331.   {"application/x-troff","tr"},
  332.   {"application/x-troff","roff"},
  333.   {"application/x-troff-man","man"},
  334.   {"application/x-troff-me","ms"},
  335.   {"application/x-wais-source","src"},
  336.   {"application/zip","zip"},
  337.   {"application/x-zip-compressed","zip"},
  338.   {"application/x-bcpio","bcpio"},
  339.   {"application/x-cdlink","vcd"},
  340.   {"application/x-cpio","cpio"},
  341.   {"application/x-gtar","tgz"},
  342.   {"application/x-gtar","gtar"},
  343.   {"application/x-shar","shar"},
  344.   {"application/x-shockwave-flash","swf"},
  345.   {"application/x-sv4cpio","sv4cpio"},
  346.   {"application/x-sv4crc","sv4crc"},
  347.   {"application/x-tar","tar"},
  348.   {"application/x-ustar","ustar"},
  349.   {"application/x-winhelp","hlp"},
  350.   {"audio/midi","mid"},
  351.   {"audio/midi","midi"},
  352.   {"audio/midi","kar"},
  353.   {"audio/mpeg","mp3"},
  354.   {"audio/mpeg","mpga"},
  355.   {"audio/mpeg","mp2"},
  356.   {"audio/basic","au"},
  357.   {"audio/basic","snd"},
  358.   {"audio/x-aiff","aif"},
  359.   {"audio/x-aiff","aiff"},
  360.   {"audio/x-aiff","aifc"},
  361.   {"audio/x-pn-realaudio","rm"},
  362.   {"audio/x-pn-realaudio","ram"},
  363.   {"audio/x-pn-realaudio","ra"},
  364.   {"audio/x-pn-realaudio-plugin","rpm"},
  365.   {"audio/x-wav","wav"},
  366.   {"chemical/x-pdb","pdb"},
  367.   {"chemical/x-pdb","xyz"},
  368.   {"drawing/x-dwf","dwf"},
  369.   {"image/gif","gif"},
  370.   {"image/ief","ief"},
  371.   {"image/jpeg","jpg"},
  372.   {"image/jpeg","jpe"},
  373.   {"image/jpeg","jpeg"},
  374.   {"image/pict","pict"},
  375.   {"image/png","png"},
  376.   {"image/tiff","tiff"},
  377.   {"image/tiff","tif"},
  378.   {"image/svg+xml","svg"},
  379.   {"image/svg-xml","svg"},
  380.   {"image/x-cmu-raster","ras"},
  381.   {"image/x-freehand","fh4"},
  382.   {"image/x-freehand","fh7"},
  383.   {"image/x-freehand","fh5"},  
  384.   {"image/x-freehand","fhc"},
  385.   {"image/x-freehand","fh"},   
  386.   {"image/x-portable-anymap","pnm"},
  387.   {"image/x-portable-bitmap","pgm"},
  388.   {"image/x-portable-pixmap","ppm"},
  389.   {"image/x-rgb","rgb"},
  390.   {"image/x-xbitmap","xbm"},
  391.   {"image/x-xpixmap","xpm"},
  392.   {"image/x-xwindowdump","xwd"},
  393.   {"model/mesh","msh"},  
  394.   {"model/mesh","mesh"},  
  395.   {"model/mesh","silo"},  
  396.   {"multipart/x-zip","zip"},
  397.   {"multipart/x-gzip","gzip"},
  398.   {"text/css","css"},
  399.   {"text/html","html"},
  400.   {"text/html","htm"},
  401.   {"text/plain","txt"},
  402.   {"text/plain","g"},
  403.   {"text/plain","h"},
  404.   {"text/plain","c"},
  405.   {"text/plain","cc"},
  406.   {"text/plain","hh"},
  407.   {"text/plain","m"},
  408.   {"text/plain","f90"},
  409.   {"text/richtext","rtx"},
  410.   {"text/tab-separated-values","tsv"},
  411.   {"text/x-setext","etx"},
  412.   {"text/x-sgml","sgml"},
  413.   {"text/x-sgml","sgm"},
  414.   {"text/xml","xml"},  
  415.   {"text/xml","dtd"},  
  416.   {"video/mpeg","mpeg"},
  417.   {"video/mpeg","mpg"},
  418.   {"video/mpeg","mpe"},
  419.   {"video/quicktime","qt"},
  420.   {"video/quicktime","mov"},
  421.   {"video/x-msvideo","avi"},
  422.   {"video/x-sgi-movie","movie"},
  423.   {"x-conference/x-cooltalk","ice"},
  424.   /*{"application/x-httpd-cgi","cgi"},*/
  425.   {"x-world/x-vrml","wrl"},
  426.  
  427.   /* More from w3schools.com */
  428.   { "application/envoy", "evy" },
  429.   { "application/fractals", "fif" },
  430.   { "application/futuresplash", "spl" },
  431.   { "application/hta", "hta" },
  432.   { "application/internet-property-stream", "acx" },
  433.   { "application/msword", "dot" },
  434.   { "application/olescript", "axs" },
  435.   { "application/pics-rules", "prf" },
  436.   { "application/pkcs10", "p10" },
  437.   { "application/pkix-crl", "crl" },
  438.   { "application/set-payment-initiation", "setpay" },
  439.   { "application/set-registration-initiation", "setreg" },
  440.   { "application/vnd.ms-excel", "xla" },
  441.   { "application/vnd.ms-excel", "xlc" },
  442.   { "application/vnd.ms-excel", "xlm" },
  443.   { "application/vnd.ms-excel", "xls" },
  444.   { "application/vnd.ms-excel", "xlt" },
  445.   { "application/vnd.ms-excel", "xlw" },
  446.   { "application/vnd.ms-pkicertstore", "sst" },
  447.   { "application/vnd.ms-pkiseccat", "cat" },
  448.   { "application/vnd.ms-powerpoint", "pot" },
  449.   { "application/vnd.ms-powerpoint", "pps" },
  450.   { "application/vnd.ms-powerpoint", "ppt" },
  451.   { "application/vnd.ms-project", "mpp" },
  452.   { "application/vnd.ms-works", "wcm" },
  453.   { "application/vnd.ms-works", "wdb" },
  454.   { "application/vnd.ms-works", "wks" },
  455.   { "application/vnd.ms-works", "wps" },
  456.   { "application/x-compress", "z" },
  457.   { "application/x-compressed", "tgz" },
  458.   { "application/x-internet-signup", "ins" },
  459.   { "application/x-internet-signup", "isp" },
  460.   { "application/x-iphone", "iii" },
  461.   { "application/x-javascript", "js" },
  462.   { "application/x-msaccess", "mdb" },
  463.   { "application/x-mscardfile", "crd" },
  464.   { "application/x-msclip", "clp" },
  465.   { "application/x-msmediaview", "m13" },
  466.   { "application/x-msmediaview", "m14" },
  467.   { "application/x-msmediaview", "mvb" },
  468.   { "application/x-msmetafile", "wmf" },
  469.   { "application/x-msmoney", "mny" },
  470.   { "application/x-mspublisher", "pub" },
  471.   { "application/x-msschedule", "scd" },
  472.   { "application/x-msterminal", "trm" },
  473.   { "application/x-perfmon", "pma" },
  474.   { "application/x-perfmon", "pmc" },
  475.   { "application/x-perfmon", "pml" },
  476.   { "application/x-perfmon", "pmr" },
  477.   { "application/x-perfmon", "pmw" },
  478.   { "application/x-pkcs12", "p12" },
  479.   { "application/x-pkcs12", "pfx" },
  480.   { "application/x-pkcs7-certificates", "p7b" },
  481.   { "application/x-pkcs7-certificates", "spc" },
  482.   { "application/x-pkcs7-certreqresp", "p7r" },
  483.   { "application/x-pkcs7-mime", "p7c" },
  484.   { "application/x-pkcs7-mime", "p7m" },
  485.   { "application/x-pkcs7-signature", "p7s" },
  486.   { "application/x-troff-me", "me" },
  487.   { "application/x-x509-ca-cert", "cer" },
  488.   { "application/x-x509-ca-cert", "crt" },
  489.   { "application/x-x509-ca-cert", "der" },
  490.   { "application/ynd.ms-pkipko", "pko" },
  491.   { "audio/mid", "mid" },
  492.   { "audio/mid", "rmi" },
  493.   { "audio/mpeg", "mp3" },
  494.   { "audio/x-mpegurl", "m3u" },
  495.   { "image/bmp", "bmp" },
  496.   { "image/cis-cod", "cod" },
  497.   { "image/pipeg", "jfif" },
  498.   { "image/x-cmx", "cmx" },
  499.   { "image/x-icon", "ico" },
  500.   { "image/x-portable-bitmap", "pbm" },
  501.   { "message/rfc822", "mht" },
  502.   { "message/rfc822", "mhtml" },
  503.   { "message/rfc822", "nws" },
  504.   { "text/css", "css" },
  505.   { "text/h323", "323" },
  506.   { "text/html", "stm" },
  507.   { "text/iuls", "uls" },
  508.   { "text/plain", "bas" },
  509.   { "text/scriptlet", "sct" },
  510.   { "text/webviewhtml", "htt" },
  511.   { "text/x-component", "htc" },
  512.   { "text/x-vcard", "vcf" },
  513.   { "video/mpeg", "mp2" },
  514.   { "video/mpeg", "mpa" },
  515.   { "video/mpeg", "mpv2" },
  516.   { "video/x-la-asf", "lsf" },
  517.   { "video/x-la-asf", "lsx" },
  518.   { "video/x-ms-asf", "asf" },
  519.   { "video/x-ms-asf", "asr" },
  520.   { "video/x-ms-asf", "asx" },
  521.   { "x-world/x-vrml", "flr" },
  522.   { "x-world/x-vrml", "vrml" },
  523.   { "x-world/x-vrml", "wrz" },
  524.   { "x-world/x-vrml", "xaf" },
  525.   { "x-world/x-vrml", "xof" },
  526.  
  527.   /* Various */
  528.   { "application/ogg", "ogg" },
  529.  
  530.   {"*","class"},
  531.   
  532.   {"",""}};
  533.  
  534.  
  535. // Reserved (RFC2396)
  536. #define CIS(c,ch) ( ((unsigned char)(c)) == (ch) )
  537. #define CHAR_RESERVED(c)  ( CIS(c,';') \
  538.                          || CIS(c,'/') \
  539.                          || CIS(c,'?') \
  540.                          || CIS(c,':') \
  541.                          || CIS(c,'@') \
  542.                          || CIS(c,'&') \
  543.                          || CIS(c,'=') \
  544.                          || CIS(c,'+') \
  545.                          || CIS(c,'$') \
  546.                          || CIS(c,',') )
  547. //#define CHAR_RESERVED(c)  ( strchr(";/?:@&=+$,",(unsigned char)(c)) != 0 )
  548. // Delimiters (RFC2396)
  549. #define CHAR_DELIM(c)     ( CIS(c,'<') \
  550.                          || CIS(c,'>') \
  551.                          || CIS(c,'#') \
  552.                          || CIS(c,'%') \
  553.                          || CIS(c,'\"') )
  554. //#define CHAR_DELIM(c)     ( strchr("<>#%\"",(unsigned char)(c)) != 0 )
  555. // Unwise (RFC2396)
  556. #define CHAR_UNWISE(c)    ( CIS(c,'{') \
  557.                          || CIS(c,'}') \
  558.                          || CIS(c,'|') \
  559.                          || CIS(c,'\\') \
  560.                          || CIS(c,'^') \
  561.                          || CIS(c,'[') \
  562.                          || CIS(c,']') \
  563.                          || CIS(c,'`') )
  564. //#define CHAR_UNWISE(c)    ( strchr("{}|\\^[]`",(unsigned char)(c)) != 0 )
  565. // Special (escape chars) (RFC2396 + >127 )
  566. #define CHAR_LOW(c)       ( ((unsigned char)(c) <= 31) )
  567. #define CHAR_HIG(c)       ( ((unsigned char)(c) >= 127) )
  568. #define CHAR_SPECIAL(c)   ( CHAR_LOW(c) || CHAR_HIG(c) )
  569. // We try to avoid them and encode them instead
  570. #define CHAR_XXAVOID(c)   ( CIS(c,' ') \
  571.                          || CIS(c,'*') \
  572.                          || CIS(c,'\'') \
  573.                          || CIS(c,'\"') \
  574.                          || CIS(c,'&') \
  575.                          || CIS(c,'!') )
  576. //#define CHAR_XXAVOID(c)   ( strchr(" *'\"!",(unsigned char)(c)) != 0 )
  577. #define CHAR_MARK(c)      ( CIS(c,'-') \
  578.                          || CIS(c,'_') \
  579.                          || CIS(c,'.') \
  580.                          || CIS(c,'!') \
  581.                          || CIS(c,'~') \
  582.                          || CIS(c,'*') \
  583.                          || CIS(c,'\'') \
  584.                          || CIS(c,'(') \
  585.                          || CIS(c,')') )
  586. //#define CHAR_MARK(c)      ( strchr("-_.!~*'()",(unsigned char)(c)) != 0 )
  587.  
  588.  
  589.  
  590. // conversion Θventuelle / vers antislash
  591. #if HTS_WIN
  592. char* antislash(char* s) {
  593.   char* buff;
  594.   char* a;
  595.   NOSTATIC_RESERVE(buff, char, HTS_URLMAXSIZE*2);
  596.  
  597.   strcpybuff(buff,s);
  598.   while(a=strchr(buff,'/')) *a='\\';
  599.   return buff;
  600. }
  601. #endif
  602.  
  603. #ifdef _WIN32_WCE
  604. char cwd[MAX_PATH+1] = "";
  605. #endif
  606.  
  607. // RΘcupΘration d'un fichier http sur le net.
  608. // Renvoie une adresse sur le bloc de mΘmoire, ou bien
  609. // NULL si un retour.msgeur (buffer retour.msg) est survenue. 
  610. //
  611. // Une adresse de structure htsmsg peut Ωtre transmise pour
  612. // suivre l'Θvolution du chargement si le process a ΘtΘ lancΘ 
  613. // en background
  614.  
  615. htsblk httpget(char* url) {
  616.   char BIGSTK adr[HTS_URLMAXSIZE*2];   // adresse
  617.   char BIGSTK fil[HTS_URLMAXSIZE*2];   // chemin
  618.   
  619.   // sΘparer URL en adresse+chemin
  620.   if (ident_url_absolute(url,adr,fil)==-1) {
  621.     htsblk retour;
  622.     memset(&retour, 0, sizeof(htsblk));    // effacer
  623.     // retour prΘdΘfini: erreur
  624.     retour.adr=NULL;
  625.     retour.size=0;
  626.     retour.msg[0]='\0';
  627.     retour.statuscode=-1;    
  628.     strcpybuff(retour.msg,"Error invalid URL");
  629.     return retour;
  630.   }
  631.   
  632.   return xhttpget(adr,fil);
  633. }
  634.  
  635. // ouvre une liaison http, envoie une requΦte GET et rΘceptionne le header
  636. // retour: socket
  637. int http_fopen(char* adr,char* fil,htsblk* retour) {
  638.   //                / GET, traiter en-tΩte
  639.   return http_xfopen(0,1,1,NULL,adr,fil,retour);
  640. }
  641.  
  642. // ouverture d'une liaison http, envoi d'une requΦte
  643. // mode: 0 GET  1 HEAD  [2 POST]
  644. // treat: traiter header?
  645. // waitconnect: attendre le connect()
  646. // note: dans retour, on met les params du proxy
  647. int http_xfopen(int mode,int treat,int waitconnect,char* xsend,char* adr,char* fil,htsblk* retour) {
  648.   //htsblk retour;
  649.   //int bufl=TAILLE_BUFFER;    // 8Ko de buffer
  650.   T_SOC soc=INVALID_SOCKET;
  651.   //char *p,*q;
  652.   
  653.   // retour prΘdΘfini: erreur
  654.   if (retour) {
  655.     retour->adr=NULL;
  656.     retour->size=0;
  657.     retour->msg[0]='\0';
  658.     retour->statuscode=-5;          // a priori erreur non fatale
  659.   }
  660.  
  661. #if HDEBUG
  662.   printf("adr=%s\nfichier=%s\n",adr,fil);
  663. #endif
  664.   
  665.   // ouvrir liaison
  666. #if HDEBUG
  667.   printf("CrΘation d'une socket sur %s\n",adr);
  668. #endif
  669.  
  670. #if CNXDEBUG
  671.   printf("..newhttp\n");
  672. #endif
  673.  
  674.   /* connexion */
  675.   if (retour) {
  676.     if ( (!(retour->req.proxy.active)) 
  677.       ||
  678.       (
  679.         (strcmp(adr,"file://")==0) 
  680.         ||
  681.         (strncmp(adr,"https://", 8)==0) 
  682.       )
  683.       ) {    /* pas de proxy, ou non utilisable ici */
  684.       soc=newhttp(adr,retour,-1,waitconnect);
  685.     } else {
  686.       soc=newhttp(retour->req.proxy.name,retour,retour->req.proxy.port,waitconnect);  // ouvrir sur le proxy α la place
  687.     }
  688.   } else {
  689.     soc=newhttp(adr,NULL,-1,waitconnect);    
  690.   }
  691.  
  692.   // copier index socket retour
  693.   if (retour) retour->soc=soc;
  694.  
  695.   /* Check for errors */
  696.   if (soc == INVALID_SOCKET) {
  697.     if (retour) {
  698.       if (retour->msg) {
  699.         if (!strnotempty(retour->msg)) {
  700.           strcpybuff(retour->msg,"Connect error");
  701.         }
  702.       }
  703.     }
  704.   }
  705.  
  706.   // --------------------
  707.   // court-circuit (court circuite aussi le proxy..)
  708.   // LOCAL_SOCKET_ID est une pseudo-socket locale
  709.   if (soc==LOCAL_SOCKET_ID) {
  710.     retour->is_file=1;  // fichier local
  711.     if (mode==0) {    // GET
  712.  
  713.       // Test en cas de file:///C|...
  714.       if (!fexist(fconv(unescape_http(fil))))
  715.         if (fexist(fconv(unescape_http(fil+1)))) {
  716.           char BIGSTK tempo[HTS_URLMAXSIZE*2];
  717.           strcpybuff(tempo,fil+1);
  718.           strcpybuff(fil,tempo);
  719.         }
  720.  
  721.       // Ouvrir
  722.       retour->totalsize=fsize(fconv(unescape_http(fil)));  // taille du fichier
  723.       retour->msg[0]='\0';
  724.       soc=INVALID_SOCKET;
  725.       if (retour->totalsize<0)
  726.         strcpybuff(retour->msg,"Unable to open local file");
  727.       else if (retour->totalsize==0)
  728.         strcpybuff(retour->msg,"File empty");
  729.       else {
  730.         // Note: On passe par un FILE* (plus propre)
  731.         //soc=open(fil,O_RDONLY,0);    // en lecture seule!
  732.         retour->fp=fopen(fconv(unescape_http(fil)),"rb");  // ouvrir
  733.         if (retour->fp==NULL)
  734.           soc=INVALID_SOCKET;
  735.         else
  736.           soc=LOCAL_SOCKET_ID;
  737.       }
  738.       retour->soc=soc;
  739.       if (soc!=INVALID_SOCKET) {
  740.         retour->statuscode=200;   // OK
  741.         strcpybuff(retour->msg,"OK");
  742.         guess_httptype(retour->contenttype,fil);
  743.       } else if (strnotempty(retour->msg)==0)
  744.           strcpybuff(retour->msg,"Unable to open local file");
  745.       return soc;  // renvoyer
  746.     } else {    // HEAD ou POST : interdit sur un local!!!! (c'est idiot!)
  747.       strcpybuff(retour->msg,"Unexpected Head/Post local request");
  748.       soc=INVALID_SOCKET;    // erreur
  749.       retour->soc=soc;
  750.       return soc;
  751.     }
  752.   } 
  753.   // --------------------
  754.  
  755.   if (soc!=INVALID_SOCKET) {    
  756.     char rcvd[1100];
  757.     rcvd[0]='\0';
  758. #if HDEBUG
  759.     printf("Ok, connexion rΘussie, id=%d\n",soc);
  760. #endif
  761.     
  762.     // connectΘ?
  763.     if (waitconnect) {
  764.       http_sendhead(NULL,mode,xsend,adr,fil,NULL,NULL,retour);
  765.     } 
  766.     
  767.     if (soc!=INVALID_SOCKET) {
  768.       
  769. #if HDEBUG
  770.       printf("Attente de la rΘponse:\n");
  771. #endif
  772.       
  773.       // si GET (rΘception d'un fichier), rΘceptionner en-tΩte d'abord,
  774.       // et ensuite le corps
  775.       // si POST on ne rΘceptionne rien du tout, c'est aprΦs que l'on fera
  776.       // une rΘception standard pour rΘcupΘrer l'en tΩte
  777.       if ((treat) && (waitconnect)) {  // traiter (attendre!) en-tΩte        
  778.         // RΘception de la status line et de l'en-tΩte (norme RFC1945)
  779.         
  780.         // status-line α rΘcupΘrer
  781.         finput(soc,rcvd,1024);
  782.         if (strnotempty(rcvd)==0)
  783.           finput(soc,rcvd,1024);    // "certains serveurs buggΘs envoient un \n au dΘbut" (RFC)
  784.  
  785.         // traiter status-line
  786.         treatfirstline(retour,rcvd);
  787.  
  788. #if HDEBUG
  789.         printf("Status-Code=%d\n",retour->statuscode);
  790. #endif
  791.         
  792.         // en-tΩte
  793.         
  794.         // header // ** !attention! HTTP/0.9 non supportΘ
  795.         do {
  796.           finput(soc,rcvd,1024);          
  797. #if HDEBUG
  798.           printf(">%s\n",rcvd);      
  799. #endif
  800.           if (strnotempty(rcvd))
  801.             treathead(NULL,NULL,NULL,retour,rcvd);  // traiter
  802.  
  803.         } while(strnotempty(rcvd));
  804.         
  805.         //rcvsize=-1;    // forCER CHARGEMENT INCONNU
  806.         
  807.         //if (retour)
  808.         //  retour->totalsize=rcvsize;
  809.         
  810.       } else { // si GET, on recevra l'en tΩte APRES
  811.         //rcvsize=-1;    // on ne connait pas la taille de l'en-tΩte
  812.         if (retour)
  813.           retour->totalsize=-1;
  814.       }
  815.       
  816.     }
  817.  
  818.   }
  819.     
  820.   return soc;
  821. }
  822.  
  823.  
  824. // envoi d'une requΦte
  825. int http_sendhead(t_cookie* cookie,int mode,char* xsend,char* adr,char* fil,char* referer_adr,char* referer_fil,htsblk* retour) {
  826.   char BIGSTK buff[8192];
  827.   //int use_11=0;     // HTTP 1.1 utilisΘ
  828.   int direct_url=0; // ne pas analyser l'url (exemple: ftp://)
  829.   char* search_tag=NULL;
  830.   buff[0]='\0';
  831.  
  832.   // header Date
  833.   //strcatbuff(buff,"Date: ");
  834.   //time_gmt_rfc822(buff);    // obtenir l'heure au format rfc822
  835.   //sendc("\n");
  836.   //strcatbuff(buff,buff);
  837.  
  838.   // possibilitΘ non documentΘe: >post: et >postfile:
  839.   // si prΘsence d'un tag >post: alors executer un POST
  840.   // exemple: http://www.someweb.com/test.cgi?foo>post:posteddata=10&foo=5
  841.   // si prΘsence d'un tag >postfile: alors envoyer en tΩte brut contenu dans le fichier en question
  842.   // exemple: http://www.someweb.com/test.cgi?foo>postfile:post0.txt
  843.   search_tag=strstr(fil,POSTTOK":");
  844.   if (!search_tag) {
  845.     search_tag=strstr(fil,POSTTOK"file:");
  846.     if (search_tag) {     // postfile
  847.       if (mode==0) {      // GET!
  848.         FILE* fp=fopen(unescape_http(search_tag+strlen(POSTTOK)+5),"rb");
  849.         if (fp) {
  850.           char BIGSTK line[1100];
  851.           char BIGSTK protocol[256],url[HTS_URLMAXSIZE*2],method[256];
  852.           linput(fp,line,1000);
  853.           if (sscanf(line,"%s %s %s",method,url,protocol) == 3) {
  854.             // selon que l'on a ou pas un proxy
  855.             if (retour->req.proxy.active)
  856.               sprintf(buff,"%s http://%s%s %s\r\n",method,adr,url,protocol);
  857.             else
  858.               sprintf(buff,"%s %s %s\r\n",method,url,protocol);
  859.             // lire le reste en brut
  860.             fread(buff+strlen(buff),8000-strlen(buff),1,fp);
  861.           }
  862.           fclose(fp);
  863.         }
  864.       }
  865.     }
  866.   }
  867.   // Fin postfile
  868.   
  869.   if (strnotempty(buff)==0) {    // PAS POSTFILE
  870.     // Type de requΦte?
  871.     if ((search_tag) && (mode==0)) {
  872.       strcatbuff(buff,"POST ");
  873.     } else if (mode==0) {    // GET
  874.       strcatbuff(buff,"GET ");
  875.     } else {  // if (mode==1) {
  876.       if (!retour->req.http11)        // forcer HTTP/1.0
  877.         strcatbuff(buff,"GET ");      // certains serveurs (cgi) buggent avec HEAD
  878.       else
  879.         strcatbuff(buff,"HEAD ");
  880.     }
  881.     
  882.     // si on gΦre un proxy, il faut une Absolute URI: on ajoute avant http://www.adr.dom
  883.     if ( retour->req.proxy.active && (strncmp(adr,"https://", 8) != 0) ) {
  884.       if (!link_has_authority(adr)) {  // default http
  885. #if HDEBUG
  886.         printf("Proxy Use: for %s%s proxy %d port %d\n",adr,fil,retour->req.proxy.name,retour->req.proxy.port);
  887. #endif
  888.         strcatbuff(buff,"http://");
  889.         strcatbuff(buff,jump_identification(adr));
  890.       } else {          // ftp:// en proxy http
  891. #if HDEBUG
  892.         printf("Proxy Use for ftp: for %s%s proxy %d port %d\n",adr,fil,retour->req.proxy.name,retour->req.proxy.port);
  893. #endif
  894.         direct_url=1;             // ne pas analyser user/pass
  895.         strcatbuff(buff,adr);
  896.       }
  897.     } 
  898.     
  899.     // NOM DU FICHIER
  900.     // on slash doit Ωtre prΘsent en dΘbut, sinon attention aux bad request! (400)
  901.     if (*fil!='/') strcatbuff(buff,"/");
  902.     {
  903.       char BIGSTK tempo[HTS_URLMAXSIZE*2];
  904.       tempo[0]='\0';
  905.       if (search_tag)
  906.         strncatbuff(tempo,fil,(int) (search_tag - fil));
  907.       else
  908.         strcpybuff(tempo,fil);
  909.       escape_check_url(tempo);
  910.       strcatbuff(buff,tempo);       // avec Θchappement
  911.     }
  912.     
  913.     // protocole
  914.     if (!retour->req.http11) {     // forcer HTTP/1.0
  915.       //use_11=0;
  916.       strcatbuff(buff," HTTP/1.0\x0d\x0a");
  917.     } else {                   // RequΦte 1.1
  918.       //use_11=1;
  919.       strcatbuff(buff," HTTP/1.1\x0d\x0a");
  920.     }
  921.  
  922.     /* supplemental data */
  923.     if (xsend) strcatbuff(buff,xsend);    // Θventuelles autres lignes
  924.  
  925.     // tester proxy authentication
  926.     if (retour->req.proxy.active) {
  927.       if (link_has_authorization(retour->req.proxy.name)) {  // et hop, authentification proxy!
  928.         char* a=jump_identification(retour->req.proxy.name);
  929.         char* astart=jump_protocol(retour->req.proxy.name);
  930.         char autorisation[1100];
  931.         char user_pass[256];        
  932.         autorisation[0]=user_pass[0]='\0';
  933.         //
  934.         strncatbuff(user_pass,astart,(int) (a - astart) - 1);
  935.         strcpybuff(user_pass,unescape_http(user_pass));
  936.         code64((unsigned char*)user_pass,(int)strlen(user_pass),(unsigned char*)autorisation,0);
  937.         strcatbuff(buff,"Proxy-Authorization: Basic ");
  938.         strcatbuff(buff,autorisation);
  939.         strcatbuff(buff,H_CRLF);
  940. #if HDEBUG
  941.         printf("Proxy-Authenticate, %s (code: %s)\n",user_pass,autorisation);
  942. #endif
  943.       }
  944.     }
  945.     
  946.     // Referer?
  947.     if (referer_adr != NULL && referer_fil != NULL 
  948.       && strnotempty(referer_adr) && strnotempty(referer_fil)
  949.       ) {   // non vide
  950.       if (
  951.         (strcmp(referer_adr,"file://") != 0)
  952.         &&
  953.         (  /* no https referer to http urls */
  954.         (strncmp(referer_adr, "https://", 8) != 0)  /* referer is not https */
  955.         ||
  956.         (strncmp(adr, "https://", 8) == 0)          /* or referer AND addresses are https */
  957.         )
  958.         ) {      // PAS file://
  959.         strcatbuff(buff,"Referer: ");
  960.         strcatbuff(buff,"http://");
  961.         strcatbuff(buff,jump_identification(referer_adr));
  962.         strcatbuff(buff,referer_fil);
  963.         strcatbuff(buff,H_CRLF);
  964.       }
  965.     }
  966.     // HTTP field: referer
  967.     else if (retour->req.referer[0] != '\0') {
  968.       strcatbuff(buff,"Referer: ");
  969.       strcatbuff(buff, retour->req.referer);
  970.       strcatbuff(buff, H_CRLF);     
  971.     }
  972.     
  973.     // POST?
  974.     if (mode==0) {      // GET!
  975.       if (search_tag) {
  976.         char clen[256];
  977.         sprintf(clen,"Content-length: %d"H_CRLF,(int)(strlen(unescape_http(search_tag+strlen(POSTTOK)+1))));
  978.         strcatbuff(buff,clen);
  979.       }
  980.     }
  981.     
  982.     // gestion cookies?
  983.     if (cookie) {
  984.       char* b=cookie->data;
  985.       int cook=0;
  986.       int max_cookies=8;
  987.       int max_size=2048;
  988.       max_size+=strlen(buff);
  989.       do {
  990.         b=cookie_find(b,"",jump_identification(adr),fil);       // prochain cookie satisfaisant aux conditions
  991.         if (b) {
  992.           max_cookies--;
  993.           if (!cook) {
  994.             strcatbuff(buff,"Cookie: ");
  995.             strcatbuff(buff,"$Version=1; ");
  996.             cook=1;
  997.           } else
  998.             strcatbuff(buff,"; ");
  999.           strcatbuff(buff,cookie_get(b,5));
  1000.           strcatbuff(buff,"=");
  1001.           strcatbuff(buff,cookie_get(b,6));
  1002.           strcatbuff(buff,"; $Path=");
  1003.           strcatbuff(buff,cookie_get(b,2));
  1004.           b=cookie_nextfield(b);
  1005.         }
  1006.       } while( (b) && (max_cookies>0) && ((int)strlen(buff)<max_size));
  1007.       if (cook) {                           // on a envoyΘ un (ou plusieurs) cookie?
  1008.         strcatbuff(buff,H_CRLF);
  1009. #if DEBUG_COOK
  1010.         printf("Header:\n%s\n",buff);
  1011. #endif
  1012.       }
  1013.     }
  1014.     
  1015.     // gΘrer le keep-alive (garder socket)
  1016.     if (retour->req.http11 && !retour->req.nokeepalive) {
  1017.             strcatbuff(buff,"Connection: Keep-Alive"H_CRLF);
  1018.         } else {
  1019.       strcatbuff(buff,"Connection: close"H_CRLF);
  1020.         }
  1021.     
  1022.     {
  1023.       char* real_adr=jump_identification(adr);
  1024.       //if ((use_11) || (retour->user_agent_send)) {   // Pour le 1.1 on utilise un Host:
  1025.       if (!direct_url) {     // pas ftp:// par exemple
  1026.         //if (!retour->req.proxy.active) {
  1027.         strcatbuff(buff,"Host: "); strcatbuff(buff,real_adr); strcatbuff(buff,H_CRLF);
  1028.         //}
  1029.       }
  1030.       //}
  1031.  
  1032.       // HTTP field: from
  1033.       if (retour->req.from[0] != '\0') {  // HTTP from
  1034.         strcatbuff(buff,"From: ");
  1035.         strcatbuff(buff, retour->req.from);
  1036.         strcatbuff(buff, H_CRLF);
  1037.       }
  1038.  
  1039.       // PrΘsence d'un user-agent?
  1040.       if (retour->req.user_agent_send) {  // ohh un user-agent
  1041.         char s[256];
  1042.         // HyperTextSeeker/"HTSVERSION
  1043.         sprintf(s,"User-Agent: %s"H_CRLF,retour->req.user_agent);
  1044.         strcatbuff(buff,s);
  1045.         
  1046.         // pour les serveurs difficiles
  1047.         strcatbuff(buff,"Accept: "
  1048.                         "image/png, image/jpeg, image/pjpeg, image/x-xbitmap, image/svg+xml"  /* Accepted */
  1049.                         ", "
  1050.                         "image/gif;q=0.9"  /* also accepted but with lower preference */
  1051.                         ", "
  1052.                         "*/*;q=0.1"        /* also accepted but with even lower preference */
  1053.                         H_CRLF);
  1054.         if (strnotempty(retour->req.lang_iso)) {
  1055.           strcatbuff(buff,"Accept-Language: "); strcatbuff(buff,retour->req.lang_iso); strcatbuff(buff,H_CRLF);
  1056.         }
  1057.         strcatbuff(buff,"Accept-Charset: "
  1058.                         "iso-8859-1"       /* we prefer ISO-8859-1 */
  1059.                         ", "
  1060.                         "iso-8859-*;q=0.9" /* or ISO-8859-* */
  1061.                         ", "
  1062.                         "utf-8;q=0.66"     /* UTF8 is also accepted */
  1063.                         ", "
  1064.                         "*;q=0.33"         /* and any other charset */
  1065.                         H_CRLF);   
  1066.         if (retour->req.http11) {
  1067. #if HTS_USEZLIB
  1068.           //strcatbuff(buff,"Accept-Encoding: gzip, deflate, compress, identity"H_CRLF);
  1069.           if (gz_is_available && (!retour->req.range_used) && (!retour->req.nocompression))
  1070.             strcatbuff(buff,"Accept-Encoding: "
  1071.                             "gzip"         /* gzip if the preffered encoding */
  1072.                             ", "
  1073.                             "identity;q=0.9"
  1074.                             H_CRLF);
  1075.           else
  1076.             strcatbuff(buff,"Accept-Encoding: identity"H_CRLF);       /* no compression */
  1077. #else
  1078.           strcatbuff(buff,"Accept-Encoding: identity"H_CRLF);         /* no compression */
  1079. #endif
  1080.         }
  1081.       } else {
  1082.         strcatbuff(buff,"Accept: */*"H_CRLF);         // le minimum
  1083.       }
  1084.  
  1085.       /* Authentification */
  1086.       {
  1087.         char autorisation[1100];
  1088.         char* a;
  1089.         autorisation[0]='\0';
  1090.         if (link_has_authorization(adr)) {  // ohh une authentification!
  1091.           char* a=jump_identification(adr);
  1092.           char* astart=jump_protocol(adr);
  1093.           if (!direct_url) {      // pas ftp:// par exemple
  1094.             char user_pass[256];
  1095.             user_pass[0]='\0';
  1096.             strncatbuff(user_pass,astart,(int) (a - astart) - 1);
  1097.             strcpybuff(user_pass,unescape_http(user_pass));
  1098.             code64((unsigned char*)user_pass,(int)strlen(user_pass),(unsigned char*)autorisation,0);
  1099.             if (strcmp(fil,"/robots.txt"))      /* pas robots.txt */
  1100.               bauth_add(cookie,astart,fil,autorisation);
  1101.           }
  1102.         } else if ( (a=bauth_check(cookie,real_adr,fil)) )
  1103.           strcpybuff(autorisation,a);
  1104.         /* On a une autorisation a donner?  */
  1105.         if (strnotempty(autorisation)) {
  1106.           strcatbuff(buff,"Authorization: Basic ");
  1107.           strcatbuff(buff,autorisation);
  1108.           strcatbuff(buff,H_CRLF);
  1109.         }
  1110.       }
  1111.  
  1112.     }
  1113.     //strcatbuff(buff,"Accept-Language: en\n");
  1114.     //strcatbuff(buff,"Accept-Charset: iso-8859-1,*,utf-8\n");
  1115.     
  1116.     // CRLF de fin d'en tΩte
  1117.     strcatbuff(buff,H_CRLF);
  1118.     
  1119.     // donnΘes complΘmentaires?
  1120.     if (search_tag)
  1121.     if (mode==0)      // GET!
  1122.       strcatbuff(buff,unescape_http(search_tag+strlen(POSTTOK)+1));
  1123.   }
  1124.   
  1125. #if HDEBUG
  1126. #endif
  1127.   if (_DEBUG_HEAD) {
  1128.     if (ioinfo) {
  1129.       fprintf(ioinfo,"[%d] request for %s%s:\r\n",retour->debugid,jump_identification(adr),fil);
  1130.       fprintfio(ioinfo,buff,"<<< ");
  1131.       fprintf(ioinfo,"\r\n");
  1132.       fflush(ioinfo);
  1133.     }
  1134.   }  // Fin test pas postfile
  1135.   //
  1136.  
  1137.   // Callback
  1138. #if HTS_ANALYSTE
  1139.   if (hts_htmlcheck_sendhead != NULL) {
  1140.     int test_head=hts_htmlcheck_sendhead(buff, adr, fil, referer_adr, referer_fil, retour);
  1141.     if (test_head!=1) {
  1142.       deletesoc_r(retour);
  1143.       strcpybuff(retour->msg,"Header refused by external wrapper");
  1144.       retour->soc=INVALID_SOCKET;
  1145.     }
  1146.   }
  1147. #endif
  1148.  
  1149.   // Envoi
  1150.   HTS_STAT.last_request = mtime_local();
  1151.   if (sendc(retour, buff)<0) {  // ERREUR, socket rompue?...
  1152.   //if (sendc(retour->soc,buff) != strlen(buff)) {  // ERREUR, socket rompue?...
  1153.     deletesoc_r(retour);  // fermer tout de mΩme
  1154.     // et tenter de reconnecter
  1155.     
  1156.     strcpybuff(retour->msg, "Write error");
  1157.     retour->soc=INVALID_SOCKET;
  1158.   }
  1159.   
  1160.   // RX'98
  1161.   return 0;
  1162. }
  1163.  
  1164.  
  1165.  
  1166.  
  1167. // traiter 1ere ligne d'en tΩte
  1168. void treatfirstline(htsblk* retour,char* rcvd) {
  1169.   char* a=rcvd;
  1170.   // exemple:
  1171.   // HTTP/1.0 200 OK
  1172.   if (*a) {
  1173.     // note: certains serveurs buggΘs renvoient HTTP/1.0\n200 OK ou " HTTP/1.0 200 OK"
  1174.     while ((*a==' ') || (*a==10) || (*a==13) || (*a==9)) a++;      // Θpurer espaces au dΘbut
  1175.     if (strfield(a, "HTTP/")) {
  1176.       // sauter HTTP/1.x
  1177.       while ((*a!=' ') && (*a!='\0') && (*a!=10) && (*a!=13) && (*a!=9)) a++;   
  1178.       if (*a != '\0') {
  1179.         while ((*a==' ') || (*a==10) || (*a==13) || (*a==9)) a++;      // Θpurer espaces
  1180.         if ((*a>='0') && (*a<='9')) {
  1181.           sscanf(a,"%d",&(retour->statuscode));
  1182.           // sauter 200
  1183.           while ((*a!=' ') && (*a!='\0') && (*a!=10) && (*a!=13) && (*a!=9)) a++;   
  1184.           while ((*a==' ') || (*a==10) || (*a==13) || (*a==9)) a++;      // Θpurer espaces
  1185.           if ((strlen(a) > 1) && (strlen(a) < 64) )                // message retour
  1186.             strcpybuff(retour->msg,a);
  1187.           else
  1188.             infostatuscode(retour->msg,retour->statuscode);
  1189.           // type MIME par dΘfaut2
  1190.           strcpybuff(retour->contenttype,HTS_HYPERTEXT_DEFAULT_MIME);
  1191.         } else {  // pas de code!
  1192.           retour->statuscode=-1;
  1193.           strcpybuff(retour->msg,"Unknown response structure");
  1194.         }
  1195.       } else {  // euhh??
  1196.         retour->statuscode=-1;
  1197.         strcpybuff(retour->msg,"Unknown response structure");
  1198.       }
  1199.     } else {
  1200.             if (*a == '<') {
  1201.         /* This is dirty .. */
  1202.         retour->statuscode=200;
  1203.         retour->keep_alive=0;
  1204.         strcpybuff(retour->msg, "Unknown, assuming junky server");
  1205.         strcpybuff(retour->contenttype,HTS_HYPERTEXT_DEFAULT_MIME);
  1206.             } else if (strnotempty(a)) {
  1207.         retour->statuscode=-1;
  1208.         strcpybuff(retour->msg,"Unknown (not HTTP/xx) response structure");
  1209.       } else {
  1210.         /* This is dirty .. */
  1211.         retour->statuscode=200;
  1212.         retour->keep_alive=0;
  1213.         strcpybuff(retour->msg, "Unknown, assuming junky server");
  1214.         strcpybuff(retour->contenttype,HTS_HYPERTEXT_DEFAULT_MIME);
  1215.       }
  1216.     }
  1217.   } else {  // vide!
  1218.     /*
  1219.     retour->statuscode=-1;
  1220.     strcpybuff(retour->msg,"Empty reponse or internal error");
  1221.     */
  1222.     /* This is dirty .. */
  1223.     retour->statuscode=200;
  1224.     strcpybuff(retour->msg, "Unknown, assuming junky server");
  1225.     strcpybuff(retour->contenttype,HTS_HYPERTEXT_DEFAULT_MIME);
  1226.   }
  1227. }
  1228.  
  1229. // traiter ligne par ligne l'en tΩte
  1230. // gestion des cookies
  1231. void treathead(t_cookie* cookie,char* adr,char* fil,htsblk* retour,char* rcvd) {
  1232.   int p;
  1233.   if ((p=strfield(rcvd,"Content-length:"))!=0) {
  1234. #if HDEBUG
  1235.     printf("ok, Content-length: dΘtectΘ\n");
  1236. #endif
  1237.     sscanf(rcvd+p,LLintP,&(retour->totalsize));
  1238.     if (retour->totalsize == 0) {
  1239.       retour->empty = 1;
  1240.     }
  1241.   }
  1242.   else if ((p=strfield(rcvd,"Content-Disposition:"))!=0) {
  1243.     while(is_realspace(*(rcvd+p))) p++;    // sauter espaces
  1244.     if ((int) strlen(rcvd+p)<250) { // pas trop long?
  1245.       char tmp[256];
  1246.       char *a=NULL,*b=NULL;
  1247.       strcpybuff(tmp,rcvd+p);
  1248.       a=strstr(tmp,"filename=");
  1249.       if (a) {
  1250.         a+=strlen("filename=");
  1251.         while(is_space(*a)) a++;
  1252.         //a=strchr(a,'"');
  1253.         if (a) {
  1254.           char *c=NULL;
  1255.           //a++;      /* jump " */
  1256.           while((c=strchr(a,'/')))    /* skip all / (see RFC2616) */
  1257.             a=c+1;
  1258.           //b=strchr(a+1,'"');
  1259.           b=a+strlen(a)-1;
  1260.           while(is_space(*b)) b--;
  1261.           b++;
  1262.           if (b) {
  1263.             *b='\0';
  1264.             if ((int) strlen(a) < 200) { // pas trop long?
  1265.               strcpybuff(retour->cdispo,a);
  1266.             }
  1267.           }
  1268.         }
  1269.       } 
  1270.     }
  1271.   }
  1272.   else if ((p=strfield(rcvd,"Last-Modified:"))!=0) {
  1273.     while(is_realspace(*(rcvd+p))) p++;    // sauter espaces
  1274.     if ((int) strlen(rcvd+p)<64) { // pas trop long?
  1275.       //struct tm* tm_time=convert_time_rfc822(rcvd+p);
  1276.       strcpybuff(retour->lastmodified,rcvd+p);
  1277.     }
  1278.   }
  1279.   else if ((p=strfield(rcvd,"Date:"))!=0) {
  1280.     if (strnotempty(retour->lastmodified)==0) {          /* pas encore de last-modified */
  1281.       while(is_realspace(*(rcvd+p))) p++;    // sauter espaces
  1282.       if ((int) strlen(rcvd+p)<64) { // pas trop long?
  1283.         //struct tm* tm_time=convert_time_rfc822(rcvd+p);
  1284.         strcpybuff(retour->lastmodified,rcvd+p);
  1285.       }
  1286.     }
  1287.   }
  1288.   else if ((p=strfield(rcvd,"Etag:"))!=0) {   /* Etag */
  1289.     if (retour) {
  1290.       while(is_realspace(*(rcvd+p))) p++;    // sauter espaces
  1291.       if ((int) strlen(rcvd+p)<64)  // pas trop long?
  1292.         strcpybuff(retour->etag,rcvd+p);
  1293.       else    // erreur.. ignorer
  1294.         retour->etag[0]='\0';
  1295.     }
  1296.   }
  1297.   // else if ((p=strfield(rcvd,"Transfer-Encoding: chunked"))!=0) {  // chunk!
  1298.   else if ((p=strfield(rcvd,"Transfer-Encoding:"))!=0) {  // chunk!
  1299.     while(is_realspace(*(rcvd+p))) p++;    // sauter espaces
  1300.     if (strfield(rcvd+p,"chunked")) {
  1301.       retour->is_chunk=1;     // chunked
  1302.       //retour->http11=2;     // chunked
  1303. #if HDEBUG
  1304.       printf("ok, Transfer-Encoding: dΘtectΘ\n");
  1305. #endif
  1306.     }
  1307.   }
  1308.   else if ((p=strfield(rcvd,"Content-type:"))!=0) {
  1309.     if (retour) {
  1310.       char tempo[1100];
  1311.       // Θviter les text/html; charset=foo
  1312.       {
  1313.         char* a=strchr(rcvd+p,';');
  1314.         if (a) {   // extended information
  1315.           *a='\0';
  1316.           a++;
  1317.               while(is_space(*a)) a++;
  1318.           if (strfield(a, "charset")) {
  1319.             a += 7;
  1320.                 while(is_space(*a)) a++;
  1321.             if (*a == '=') {
  1322.               a++;
  1323.                   while(is_space(*a)) a++;
  1324.               if (*a == '\"') a++;
  1325.                   while(is_space(*a)) a++;
  1326.               if (*a) {
  1327.                 char* chs = a;
  1328.                 while(*a && !is_space(*a) && *a != '\"' && *a != ';') a++;
  1329.                 *a = '\0';
  1330.                 if (*chs) {
  1331.                   if (strlen(chs) < sizeof(retour->charset) - 2) {
  1332.                     strcpybuff(retour->charset, chs);
  1333.                   }
  1334.                 }
  1335.               }
  1336.             }
  1337.           }
  1338.         }
  1339.       }
  1340.       sscanf(rcvd+p,"%s",tempo);
  1341.       if (strlen(tempo) < sizeof(retour->contenttype) - 2)    // pas trop long!!
  1342.         strcpybuff(retour->contenttype,tempo);
  1343.       else
  1344.         strcpybuff(retour->contenttype,"application/octet-stream-unknown");    // erreur
  1345.     }
  1346.   }
  1347.   else if ((p=strfield(rcvd,"Content-Range:"))!=0) {
  1348.     char* a=strstr(rcvd+p,"*/");
  1349.     if (a) {
  1350.       if (sscanf(a+2,LLintP,&retour->crange) != 1) {
  1351.         retour->crange=0;
  1352.       }
  1353.     }
  1354.   }
  1355.   else if ((p=strfield(rcvd,"Connection:"))!=0) {
  1356.         char* a = rcvd + p;
  1357.         while(is_space(*a)) a++;
  1358.         if (*a) {
  1359.             if (strfield(a, "Keep-Alive")) {
  1360.         if (!retour->keep_alive) {
  1361.           retour->keep_alive_max = 10;
  1362.           retour->keep_alive_t = 15;
  1363.         }
  1364.         retour->keep_alive = 1;
  1365.       } else {
  1366.                 retour->keep_alive = 0;
  1367.       }
  1368.         }
  1369.     }
  1370.   else if ((p=strfield(rcvd,"Keep-Alive:"))!=0) {
  1371.         char* a = rcvd + p;
  1372.         while(is_space(*a)) a++;
  1373.         if (*a) {
  1374.       char* p;
  1375.       retour->keep_alive = 1;
  1376.       retour->keep_alive_max = 10;
  1377.       retour->keep_alive_t = 15;
  1378.       if ((p=strstr(a, "timeout="))) {
  1379.         p+=strlen("timeout=");
  1380.         sscanf(p, "%d", &retour->keep_alive_t);
  1381.       }
  1382.       if ((p=strstr(a, "max="))) {
  1383.         p+=strlen("max=");
  1384.         sscanf(p, "%d", &retour->keep_alive_max);
  1385.       }
  1386.       if (retour->keep_alive_max <= 1 || retour->keep_alive_t < 3) {
  1387.         retour->keep_alive = 0;
  1388.       }
  1389.     }
  1390.   }
  1391.   else if ((p=strfield(rcvd,"TE:"))!=0) {
  1392.         char* a = rcvd + p;
  1393.         while(is_space(*a)) a++;
  1394.         if (*a) {
  1395.       if (strfield(a, "trailers")) {
  1396.         retour->keep_alive_trailers=1;
  1397.       }
  1398.     }
  1399.   }
  1400.     else if ((p=strfield(rcvd,"Content-Encoding:"))!=0) {
  1401.         if (retour) {
  1402.             char tempo[1100];
  1403.       char* a = rcvd + p;
  1404.       while(is_space(*a)) a++;
  1405.             {
  1406.                 char* a=strchr(rcvd+p,';');
  1407.                 if (a) *a='\0';
  1408.             }
  1409.             sscanf(a,"%s",tempo);
  1410.       if (strlen(tempo)<64)    // pas trop long!!
  1411.         strcpybuff(retour->contentencoding,tempo);
  1412.       else
  1413.         retour->contentencoding[0]='\0';    // erreur
  1414. #if HTS_USEZLIB
  1415.       /* Check known encodings */
  1416.       if (retour->contentencoding[0]) {
  1417.         if (
  1418.           (strfield2(retour->contentencoding, "gzip"))
  1419.           || (strfield2(retour->contentencoding, "x-gzip"))
  1420.           /*
  1421.           || (strfield2(retour->contentencoding, "compress"))
  1422.           || (strfield2(retour->contentencoding, "x-compress"))
  1423.           */
  1424.           || (strfield2(retour->contentencoding, "deflate"))
  1425.           || (strfield2(retour->contentencoding, "x-deflate"))
  1426.           ) {
  1427.         retour->compressed=1;
  1428.         }
  1429.       }
  1430. #endif
  1431.     }
  1432.   }
  1433.   else if ((p=strfield(rcvd,"Location:"))!=0) {
  1434.     if (retour) {
  1435.       if (retour->location) {
  1436.         while(is_realspace(*(rcvd+p))) p++;    // sauter espaces
  1437.         if ((int) strlen(rcvd+p)<HTS_URLMAXSIZE)  // pas trop long?
  1438.           strcpybuff(retour->location,rcvd+p);
  1439.         else    // erreur.. ignorer
  1440.           retour->location[0]='\0';
  1441.       }
  1442.     }
  1443.   }
  1444.   else if ( ((p=strfield(rcvd,"Set-Cookie:"))!=0) && (cookie) ) {    // ohh un cookie
  1445.     char* a = rcvd+p;           // pointeur
  1446.     char domain[256];           // domaine cookie (.netscape.com)
  1447.     char path[256];             // chemin (/)
  1448.     char cook_name[256];        // nom cookie (MYCOOK)
  1449.     char BIGSTK cook_value[8192];      // valeur (ID=toto,S=1234)
  1450. #if DEBUG_COOK
  1451.     printf("set-cookie detected\n");
  1452. #endif
  1453.     while(*a) {
  1454.       char *token_st,*token_end;
  1455.       char *value_st,*value_end;
  1456.       char name[256];
  1457.       char BIGSTK value[8192];
  1458.       int next=0;
  1459.       name[0]=value[0]='\0';
  1460.       //
  1461.  
  1462.       // initialiser cookie lu actuellement
  1463.       if (adr)
  1464.         strcpybuff(domain,jump_identification(adr));     // domaine
  1465.       strcpybuff(path,"/");         // chemin (/)
  1466.       strcpybuff(cook_name,"");     // nom cookie (MYCOOK)
  1467.       strcpybuff(cook_value,"");    // valeur (ID=toto,S=1234)
  1468.       // boucler jusqu'au prochain cookie ou la fin
  1469.       do {
  1470.         char* start_loop=a;
  1471.         while(is_space(*a)) a++;    // sauter espaces
  1472.         token_st=a;                 // dΘpart token
  1473.         while((!is_space(*a)) && (*a) && (*a!=';') && (*a!='=')) a++;    // arrΩter si espace, point virgule
  1474.         token_end=a;
  1475.         while(is_space(*a)) a++;    // sauter espaces
  1476.         if (*a=='=') {    // name=value
  1477.           a++;
  1478.           while(is_space(*a)) a++;    // sauter espaces
  1479.           value_st=a;
  1480.           while( (*a!=';') && (*a)) a++;    // prochain ;
  1481.           //while( ((*a!='"') || (*(a-1)=='\\')) && (*a)) a++;    // prochain " (et pas \")
  1482.           value_end=a;
  1483.           //if (*a==';') {  // finit par un ;
  1484.           // vΘrifier dΘbordements
  1485.           if ( (((int) (token_end - token_st))<200) && (((int) (value_end - value_st))<8000)
  1486.             && (((int) (token_end - token_st))>0)   && (((int) (value_end - value_st))>0) ) {
  1487.             name[0]='\0';
  1488.             value[0]='\0';
  1489.             strncatbuff(name,token_st,(int) (token_end - token_st));
  1490.             strncatbuff(value,value_st,(int) (value_end - value_st));
  1491. #if DEBUG_COOK
  1492.             printf("detected cookie-av: name=\"%s\" value=\"%s\"\n",name,value);
  1493. #endif
  1494.             if (strfield2(name,"domain")) {
  1495.               strcpybuff(domain,value);
  1496.             }
  1497.             else if (strfield2(name,"path")) {
  1498.               strcpybuff(path,value);
  1499.             }
  1500.             else if (strfield2(name,"max-age")) {
  1501.               // ignorΘ..
  1502.             }
  1503.             else if (strfield2(name,"expires")) {
  1504.               // ignorΘ..
  1505.             }
  1506.             else if (strfield2(name,"version")) {
  1507.               // ignorΘ..
  1508.             }
  1509.             else if (strfield2(name,"comment")) {
  1510.               // ignorΘ
  1511.             }
  1512.             else if (strfield2(name,"secure")) {    // ne devrait pas arriver ici
  1513.               // ignorΘ
  1514.             }
  1515.             else {
  1516.               if (strnotempty(cook_name)==0) {          // noter premier: nom et valeur cookie
  1517.                 strcpybuff(cook_name,name);
  1518.                 strcpybuff(cook_value,value);
  1519.               } else {                             // prochain cookie
  1520.                 a=start_loop;      // on devra recommencer α cette position
  1521.                 next=1;            // enregistrer
  1522.               }
  1523.             }
  1524.           }
  1525.         }
  1526.         if (!next) {
  1527.           while((*a!=';') && (*a)) a++;    // prochain
  1528.           while(*a==';') a++;             // sauter ;
  1529.         }
  1530.       } while((*a) && (!next));
  1531.       if (strnotempty(cook_name)) {          // cookie?
  1532. #if DEBUG_COOK
  1533.         printf("new cookie: name=\"%s\" value=\"%s\" domain=\"%s\" path=\"%s\"\n",cook_name,cook_value,domain,path);
  1534. #endif
  1535.         cookie_add(cookie,cook_name,cook_value,domain,path);
  1536.       }
  1537.     }
  1538.   }
  1539. }
  1540.  
  1541.  
  1542. // transforme le message statuscode en chaεne
  1543. HTSEXT_API void infostatuscode(char* msg,int statuscode) {
  1544.   switch( statuscode) {    
  1545.     // Erreurs HTTP, selon RFC
  1546.   case 100: strcpybuff( msg,"Continue"); break; 
  1547.   case 101: strcpybuff( msg,"Switching Protocols"); break; 
  1548.   case 200: strcpybuff( msg,"OK"); break; 
  1549.   case 201: strcpybuff( msg,"Created"); break; 
  1550.   case 202: strcpybuff( msg,"Accepted"); break; 
  1551.   case 203: strcpybuff( msg,"Non-Authoritative Information"); break; 
  1552.   case 204: strcpybuff( msg,"No Content"); break; 
  1553.   case 205: strcpybuff( msg,"Reset Content"); break; 
  1554.   case 206: strcpybuff( msg,"Partial Content"); break; 
  1555.   case 300: strcpybuff( msg,"Multiple Choices"); break; 
  1556.   case 301: strcpybuff( msg,"Moved Permanently"); break; 
  1557.   case 302: strcpybuff( msg,"Moved Temporarily"); break; 
  1558.   case 303: strcpybuff( msg,"See Other"); break; 
  1559.   case 304: strcpybuff( msg,"Not Modified"); break; 
  1560.   case 305: strcpybuff( msg,"Use Proxy"); break; 
  1561.   case 306: strcpybuff( msg,"Undefined 306 error"); break; 
  1562.   case 307: strcpybuff( msg,"Temporary Redirect"); break; 
  1563.   case 400: strcpybuff( msg,"Bad Request"); break; 
  1564.   case 401: strcpybuff( msg,"Unauthorized"); break; 
  1565.   case 402: strcpybuff( msg,"Payment Required"); break; 
  1566.   case 403: strcpybuff( msg,"Forbidden"); break; 
  1567.   case 404: strcpybuff( msg,"Not Found"); break; 
  1568.   case 405: strcpybuff( msg,"Method Not Allowed"); break; 
  1569.   case 406: strcpybuff( msg,"Not Acceptable"); break; 
  1570.   case 407: strcpybuff( msg,"Proxy Authentication Required"); break; 
  1571.   case 408: strcpybuff( msg,"Request Time-out"); break; 
  1572.   case 409: strcpybuff( msg,"Conflict"); break; 
  1573.   case 410: strcpybuff( msg,"Gone"); break; 
  1574.   case 411: strcpybuff( msg,"Length Required"); break; 
  1575.   case 412: strcpybuff( msg,"Precondition Failed"); break; 
  1576.   case 413: strcpybuff( msg,"Request Entity Too Large"); break; 
  1577.   case 414: strcpybuff( msg,"Request-URI Too Large"); break; 
  1578.   case 415: strcpybuff( msg,"Unsupported Media Type"); break; 
  1579.   case 416: strcpybuff( msg,"Requested Range Not Satisfiable"); break; 
  1580.   case 417: strcpybuff( msg,"Expectation Failed"); break; 
  1581.   case 500: strcpybuff( msg,"Internal Server Error"); break; 
  1582.   case 501: strcpybuff( msg,"Not Implemented"); break; 
  1583.   case 502: strcpybuff( msg,"Bad Gateway"); break; 
  1584.   case 503: strcpybuff( msg,"Service Unavailable"); break; 
  1585.   case 504: strcpybuff( msg,"Gateway Time-out"); break; 
  1586.   case 505: strcpybuff( msg,"HTTP Version Not Supported"); break; 
  1587.     //
  1588.   default: if (strnotempty(msg)==0) strcpybuff( msg,"Unknown error"); break;
  1589.   }
  1590. }
  1591.  
  1592.  
  1593. // identique au prΘcΘdent, sauf que l'on donne adr+fil et non url complΦte
  1594. htsblk xhttpget(char* adr,char* fil) {
  1595.   T_SOC soc;
  1596.   htsblk retour;
  1597.   
  1598.   memset(&retour, 0, sizeof(htsblk));
  1599.   soc=http_fopen(adr,fil,&retour);
  1600.  
  1601.   if (soc!=INVALID_SOCKET) {
  1602.     http_fread(soc,&retour);
  1603. #if HTS_DEBUG_CLOSESOCK
  1604.     DEBUG_W("xhttpget: deletehttp\n");
  1605. #endif
  1606.     if (retour.soc!=INVALID_SOCKET) deletehttp(&retour);  // fermer
  1607.     retour.soc=INVALID_SOCKET;
  1608.   }
  1609.   return retour;
  1610. }
  1611.  
  1612. // variation sur un thΦme...
  1613. // rΘceptionne uniquement un en-tΩte (HEAD)
  1614. // retourne dans xx.adr l'adresse pointant sur le bloc de mΘmoire de l'en tΩte
  1615. htsblk http_gethead(char* adr,char* fil) {
  1616.   T_SOC soc;
  1617.   htsblk retour;
  1618.  
  1619.   memset(&retour, 0, sizeof(htsblk));
  1620.   soc=http_xfopen(1,0,1,NULL,adr,fil,&retour);  // HEAD, pas de traitement en-tΩte
  1621.  
  1622.   if (soc!=INVALID_SOCKET) {
  1623.     http_fread(soc,&retour);    // rΘception en-tΩte
  1624. #if HTS_DEBUG_CLOSESOCK
  1625.     DEBUG_W("http_gethead: deletehttp\n");
  1626. #endif
  1627.     if (retour.soc!=INVALID_SOCKET) deletehttp(&retour);  // fermer
  1628.     retour.soc=INVALID_SOCKET;
  1629.   }
  1630.   return retour;
  1631. }
  1632. // oui ca ressemble vachement α xhttpget - en Θtant sobre on peut voir LA diffΘrence..
  1633.  
  1634.  
  1635. // lecture sur une socket ouverte, le header a dΘja ΘtΘ envoyΘ dans le cas de GET
  1636. // il ne reste plus qu'α lire les donnΘes
  1637. // (pour HEAD le header est lu ici!)
  1638. void http_fread(T_SOC soc,htsblk* retour) {  
  1639.   //int bufl=TAILLE_BUFFER;    // 8Ko de buffer
  1640.   
  1641.   if (retour) retour->soc=soc;
  1642.   if (soc!=INVALID_SOCKET) {    
  1643.     // fonction de lecture d'une socket (plus propre)
  1644.     while(http_fread1(retour)!=-1);
  1645.     soc=retour->soc;
  1646.     if (retour->adr==NULL) {
  1647.       if (strnotempty(retour->msg)==0)
  1648.         sprintf(retour->msg,"Unable to read");
  1649.       return ;    // erreur
  1650.     } 
  1651.     
  1652. #if HDEBUG
  1653.     printf("Ok, donnΘes reτues\n");
  1654. #endif   
  1655.  
  1656.     return ;
  1657.     
  1658.   } 
  1659.   
  1660.   return ;
  1661. }
  1662.  
  1663. // check if data is available
  1664. int check_readinput(htsblk* r) {
  1665.   if (r->soc != INVALID_SOCKET) {
  1666.     fd_set fds;           // poll structures
  1667.     struct timeval tv;          // structure for select
  1668.     FD_ZERO(&fds);
  1669.     FD_SET(r->soc,&fds);           
  1670.     tv.tv_sec=0;
  1671.     tv.tv_usec=0;
  1672.     select(r->soc + 1,&fds,NULL,NULL,&tv);
  1673.     if (FD_ISSET(r->soc,&fds))
  1674.       return 1;
  1675.     else
  1676.       return 0;
  1677.   } else
  1678.     return 0;
  1679. }
  1680.  
  1681. // check if data is available
  1682. int check_readinput_t(T_SOC soc, int timeout) {
  1683.   if (soc != INVALID_SOCKET) {
  1684.     fd_set fds;           // poll structures
  1685.     struct timeval tv;          // structure for select
  1686.     FD_ZERO(&fds);
  1687.     FD_SET(soc,&fds);           
  1688.     tv.tv_sec=timeout;
  1689.     tv.tv_usec=0;
  1690.     select(soc + 1,&fds,NULL,NULL,&tv);
  1691.     if (FD_ISSET(soc,&fds))
  1692.       return 1;
  1693.     else
  1694.       return 0;
  1695.   } else
  1696.     return 0;
  1697. }
  1698.  
  1699.  
  1700. // lecture d'un bloc sur une socket (ou un fichier!)
  1701. // >=0 : nombre d'octets lus
  1702. // <0 : fin ou erreur
  1703. HTS_INLINE LLint http_fread1(htsblk* r) {
  1704.   //int bufl=TAILLE_BUFFER;  // taille d'un buffer max.
  1705.   return http_xfread1(r,TAILLE_BUFFER);
  1706. }
  1707.  
  1708. // idem, sauf qu'ici on peut choisir la taille max de donnΘes α recevoir
  1709. // SI bufl==0 alors le buffer est censΘ Ωtre de 8kos, et on recoit par bloc de lignes
  1710. // en Θliminant les cr (ex: header), arrΩt si double-lf
  1711. // SI bufl==-1 alors le buffer est censΘ Ωtre de 8kos, et on recoit ligne par ligne
  1712. // en Θliminant les cr (ex: header), arrΩt si double-lf
  1713. // Note: les +1 dans les malloc sont d√s α l'octet nul rajoutΘ en fin de fichier
  1714. LLint http_xfread1(htsblk* r,int bufl) {
  1715.   int nl=-1;
  1716.  
  1717.   // EOF
  1718.   if (r->totalsize > 0 && r->size == r->totalsize) {
  1719.     return READ_EOF;
  1720.   }
  1721.  
  1722.   if (bufl>0) {
  1723.     if (!r->is_write) {     // stocker en mΘmoire
  1724.       if (r->totalsize>0) {    // totalsize dΘterminΘ ET ALLOUE
  1725.         if (r->adr==NULL) {
  1726.           r->adr=(char*) malloct((INTsys) r->totalsize + 1);
  1727.           r->size=0;
  1728.         }
  1729.         if (r->adr!=NULL) {
  1730.           // lecture
  1731.           nl = hts_read(r,r->adr + ((int) r->size),(int) (r->totalsize-r->size) );     /* NO 32 bit overlow possible here (no 4GB html!) */
  1732.           // nouvelle taille
  1733.           if (nl >= 0) r->size+=nl;
  1734.  
  1735.           /*
  1736.           if (r->size >= r->totalsize)
  1737.             nl = -1;  // break
  1738.           */
  1739.           
  1740.           r->adr[r->size]='\0';    // caractΦre NULL en fin au cas o∙ l'on traite des HTML
  1741.         }
  1742.         
  1743.       } else {                 // inconnu..
  1744.         // rΘserver de la mΘmoire?
  1745.         if (r->adr==NULL) {
  1746. #if HDEBUG
  1747.           printf("..alloc xfread\n");
  1748. #endif
  1749.           r->adr=(char*) malloct(bufl + 1);
  1750.           r->size=0;
  1751.         }
  1752.         else {
  1753. #if HDEBUG
  1754.           printf("..realloc xfread1\n");
  1755. #endif
  1756.           r->adr=(char*) realloct(r->adr,(int)r->size+bufl + 1);
  1757.         }
  1758.         
  1759.         if (r->adr!=NULL) {
  1760.           // lecture
  1761.           nl = hts_read(r,r->adr+(int)r->size,bufl);
  1762.           if (nl > 0) {
  1763.             // resize
  1764.             r->adr=(char*) realloct(r->adr,(int)r->size+nl + 1);
  1765.             // nouvelle taille
  1766.             r->size+=nl;
  1767.             // octet nul
  1768.             if (r->adr) r->adr[r->size]='\0';
  1769.  
  1770.           } // sinon on a fini
  1771. #if HDEBUG
  1772.           else if (nl < 0)
  1773.             printf("..end read (%d)\n", nl);
  1774. #endif
  1775.         }
  1776. #if HDEBUG
  1777.         else printf("..-> error\n");
  1778. #endif
  1779.       }
  1780.  
  1781.       // pas de adr=erreur
  1782.       if (r->adr == NULL) nl = READ_ERROR;
  1783.  
  1784.     } else {    // stocker sur disque
  1785.       char* buff;
  1786.       buff=(char*) malloct(bufl);
  1787.       if (buff!=NULL) {
  1788.         // lecture
  1789.         nl = hts_read(r,buff,bufl);
  1790.         // nouvelle taille
  1791.         if (nl > 0) { 
  1792.           r->size+=nl;
  1793.           if ((INTsys)fwrite(buff,1,nl,r->out)!=nl) {
  1794.             r->statuscode=-1;
  1795.             strcpybuff(r->msg,"Write error on disk");
  1796.             nl=READ_ERROR;
  1797.           }
  1798.         }
  1799.  
  1800.         //if ((nl < 0) || ((r->totalsize>0) && (r->size >= r->totalsize)))
  1801.         //  nl=-1;  // break
  1802.  
  1803.         // libΘrer bloc tempo
  1804.         freet(buff);
  1805.       } else
  1806.         nl=READ_ERROR;
  1807.       
  1808.       if ((nl < 0) && (r->out!=NULL)) {
  1809.         fflush(r->out); 
  1810.       }
  1811.         
  1812.         
  1813.     } // stockage disque ou mΘmoire
  1814.  
  1815.   } else if (bufl == -2) {  // force reserve
  1816.     if (r->adr==NULL) {
  1817.       r->adr=(char*) malloct(8192);
  1818.       r->size=0;
  1819.       return 0;
  1820.     }
  1821.     return -1;
  1822.   } else {    // rΘception d'un en-tΩte octet par octet
  1823.     int count=256;
  1824.     int tot_nl=0;
  1825.     int lf_detected=0;
  1826.     int at_begining=1;
  1827.     do {
  1828.       nl = READ_INTERNAL_ERROR;
  1829.       count--;
  1830.       if (r->adr==NULL) {
  1831.         r->adr=(char*) malloct(8192);
  1832.         r->size=0;
  1833.       }
  1834.       if (r->adr!=NULL) {
  1835.         if (r->size < 8190) {
  1836.           // lecture
  1837.           nl = hts_read(r,r->adr+r->size,1);
  1838.           if (nl > 0) {
  1839.             // exit if:
  1840.             // lf detected AND already detected before
  1841.             // or
  1842.             // lf detected AND first character read
  1843.             if (*(r->adr+r->size) == 10) {
  1844.               if (lf_detected || (at_begining) || (bufl<0))
  1845.                 count=-1;
  1846.               lf_detected=1;
  1847.             }
  1848.             if (*(r->adr+r->size) != 13) {   // sauter caractΦres 13
  1849.               if (
  1850.                 (*(r->adr+r->size) != 10)
  1851.                 &&
  1852.                 (*(r->adr+r->size) != 13)
  1853.                 ) {
  1854.                 // restart for new line
  1855.                 lf_detected=0;
  1856.               }
  1857.               (r->size)++;
  1858.               at_begining=0;
  1859.             }
  1860.             *(r->adr+r->size)='\0';    // terminer par octet nul
  1861.           }
  1862.         }
  1863.       }
  1864.       if (nl >= 0) {
  1865.         tot_nl+=nl;
  1866.         if (!check_readinput(r))
  1867.           count=-1;
  1868.       }
  1869.     } while((nl >= 0) && (count>0));
  1870.     if (nl >= 0) {
  1871.       nl = tot_nl;
  1872.     }
  1873.   }
  1874.   // EOF
  1875.   if (r->totalsize > 0 && r->size == r->totalsize) {
  1876.     return READ_EOF;
  1877.   } else {
  1878.     return nl;
  1879.   }
  1880. }
  1881.  
  1882.  
  1883. // teste une adresse, et suit l'Θventuel chemin "moved"
  1884. // retourne 200 ou le code d'erreur (404=NOT FOUND, etc)
  1885. // copie dans loc la vΘritable adresse si celle-ci est diffΘrente
  1886. htsblk http_location(char* adr,char* fil,char* loc) {
  1887.   htsblk retour;
  1888.   int retry=0;
  1889.   int tryagain;
  1890.   // note: "RFC says"
  1891.   // 5 boucles au plus, on en teste au plus 8 ici
  1892.   // sinon abandon..
  1893.   do {
  1894.     tryagain=0;
  1895.     switch ((retour=http_test(adr,fil,loc)).statuscode) {
  1896.     case 200: break;   // ok!
  1897.     case 301: case 302: case 303: case 307: // moved!
  1898.       // recalculer adr et fil!
  1899.       if (ident_url_absolute(loc,adr,fil)!=-1) {
  1900.         tryagain=1;  // retenter
  1901.         retry++;     // ..encore une fois
  1902.       }
  1903.     }
  1904.   } while((tryagain) && (retry<5+3));
  1905.   return retour;
  1906. }
  1907.  
  1908.  
  1909. // teste si une URL (validitΘ, header, taille)
  1910. // retourne 200 ou le code d'erreur (404=NOT FOUND, etc)
  1911. // en cas de moved xx, dans location
  1912. // abandonne dΘsormais au bout de 30 secondes (aurevoir les sites
  1913. // qui nous font poireauter 5 heures..) -> -2=timeout
  1914. htsblk http_test(char* adr,char* fil,char* loc) {
  1915.   T_SOC soc;
  1916.   htsblk retour;
  1917.   //int rcvsize=-1;
  1918.   //char* rcv=NULL;    // adresse de retour
  1919.   //int bufl=TAILLE_BUFFER;    // 8Ko de buffer
  1920.   TStamp tl;
  1921.   int timeout=30;  // timeout pour un check (arbitraire) // **
  1922.  
  1923.   // pour abandonner un site trop lent
  1924.   tl=time_local();
  1925.  
  1926.   loc[0]='\0';
  1927.   memset(&retour, 0, sizeof(htsblk));    // effacer
  1928.   retour.location=loc;    // si non nul, contiendra l'adresse vΘritable en cas de moved xx
  1929.  
  1930.   //soc=http_fopen(adr,fil,&retour,NULL);  // ouvrir, + header
  1931.  
  1932.   // on ouvre en head, et on traite l'en tΩte
  1933.   soc=http_xfopen(1,0,1,NULL,adr,fil,&retour);  // ouvrir HEAD, + envoi header
  1934.   
  1935.   if (soc!=INVALID_SOCKET) {
  1936.     int e=0;
  1937.     // tant qu'on a des donnΘes, et qu'on ne recoit pas deux LF, et que le timeout n'arrie pas
  1938.     do {
  1939.       if (http_xfread1(&retour,0) < 0)
  1940.         e=1;
  1941.       else {
  1942.         if (retour.adr!=NULL) {
  1943.           if ((retour.adr[retour.size-1]!=10) || (retour.adr[retour.size-2]!=10))
  1944.             e=1;
  1945.         }
  1946.       }
  1947.             
  1948.       if (!e) {
  1949.         if ((time_local()-tl)>=timeout) {
  1950.           e=-1;
  1951.         }
  1952.       }
  1953.       
  1954.     } while (!e);
  1955.     
  1956.     if (e==1) {
  1957.       if (adr!=NULL) {
  1958.         int ptr=0;
  1959.         char rcvd[1100];
  1960.  
  1961.         // note: en gros recopie du traitement de back_wait()
  1962.         //
  1963.  
  1964.  
  1965.         // ----------------------------------------
  1966.         // traiter en-tΩte!
  1967.         // status-line α rΘcupΘrer
  1968.         ptr+=binput(retour.adr+ptr,rcvd,1024);
  1969.         if (strnotempty(rcvd)==0)
  1970.           ptr+=binput(retour.adr+ptr,rcvd,1024);    // "certains serveurs buggΘs envoient un \n au dΘbut" (RFC)
  1971.         
  1972.         // traiter status-line
  1973.         treatfirstline(&retour,rcvd);
  1974.         
  1975. #if HDEBUG
  1976.         printf("(Buffer) Status-Code=%d\n",retour.statuscode);
  1977. #endif
  1978.         
  1979.         // en-tΩte
  1980.         
  1981.         // header // ** !attention! HTTP/0.9 non supportΘ
  1982.         do {
  1983.           ptr+=binput(retour.adr+ptr,rcvd,1024);          
  1984. #if HDEBUG
  1985.           printf("(buffer)>%s\n",rcvd);      
  1986. #endif
  1987.           if (strnotempty(rcvd))
  1988.             treathead(NULL,NULL,NULL,&retour,rcvd);  // traiter
  1989.           
  1990.         } while(strnotempty(rcvd));
  1991.         // ----------------------------------------                    
  1992.         
  1993.         // libΘrer mΘmoire
  1994.         if (retour.adr!=NULL) { freet(retour.adr); retour.adr=NULL; }
  1995.       }
  1996.     } else {
  1997.       retour.statuscode=-2;
  1998.       strcpybuff(retour.msg,"Timeout While Testing");
  1999.     }
  2000.     
  2001.     
  2002. #if HTS_DEBUG_CLOSESOCK
  2003.     DEBUG_W("http_test: deletehttp\n");
  2004. #endif
  2005.     deletehttp(&retour);
  2006.     retour.soc=INVALID_SOCKET;
  2007.   }
  2008.   return retour;    
  2009. }
  2010.  
  2011. // CrΘe un lien (http) vers une adresse internet iadr
  2012. // retour: structure (adresse, taille, message si erreur (si !adr))
  2013. // peut ouvrir avec des connect() non bloquants: waitconnect=0/1
  2014. int newhttp(char* _iadr,htsblk* retour,int port,int waitconnect) {  
  2015.   t_fullhostent fullhostent_buffer;    // buffer pour resolver
  2016.   T_SOC soc;                           // descipteur de la socket
  2017.   char* iadr;
  2018.   // unsigned short int port;
  2019.   
  2020.   // si iadr="#" alors c'est une fausse URL, mais un vrai fichier
  2021.   // local.
  2022.   // utile pour les tests!
  2023.   //## if (iadr[0]!=lOCAL_CHAR) {
  2024.   if (strcmp(_iadr,"file://") != 0) {           /* non fichier */
  2025.     SOCaddr server;
  2026.     int server_size=sizeof(server);
  2027.     t_hostent* hp;    
  2028.     // effacer structure
  2029.     memset(&server, 0, sizeof(server));
  2030.  
  2031.     // tester un Θventuel id:pass et virer id:pass@ si dΘtectΘ
  2032.     iadr = jump_identification(_iadr);
  2033.   
  2034. #if HDEBUG
  2035.     printf("gethostbyname\n");
  2036. #endif
  2037.     
  2038.     // tester un Θventuel port
  2039.     if (port==-1) {
  2040.       char *a=jump_toport(iadr);
  2041. #if HTS_USEOPENSSL
  2042.       if (retour->ssl)
  2043.         port=443;
  2044.       else
  2045.         port=80;    // port par dΘfaut
  2046. #else
  2047.       port=80;    // port par dΘfaut
  2048. #endif
  2049.       if (a) {
  2050.         char BIGSTK iadr2[HTS_URLMAXSIZE*2];
  2051.         int i=-1;
  2052.         iadr2[0]='\0';
  2053.         sscanf(a+1,"%d",&i);
  2054.         if (i!=-1) {
  2055.           port=(unsigned short int) i;
  2056.         }
  2057.         
  2058.         // adresse vΘritable (sans :xx)
  2059.         strncatbuff(iadr2,iadr,(int) (a - iadr));
  2060.  
  2061.         // adresse sans le :xx
  2062.         hp = hts_gethostbyname(iadr2, &fullhostent_buffer);
  2063.         
  2064.       } else {
  2065.  
  2066.         // adresse normale (port par dΘfaut par la suite)
  2067.         hp = hts_gethostbyname(iadr, &fullhostent_buffer);
  2068.         
  2069.       }
  2070.       
  2071.     } else    // port dΘfini
  2072.       hp = hts_gethostbyname(iadr, &fullhostent_buffer);
  2073.  
  2074.     
  2075.     // Conversion iadr -> adresse
  2076.     // structure recevant le nom de l'h⌠te, etc
  2077.     //struct     hostent     *hp;
  2078.     if (hp == NULL) {
  2079. #if DEBUG
  2080.       printf("erreur gethostbyname\n");
  2081. #endif
  2082.       if (retour)
  2083.       if (retour->msg)
  2084.         strcpybuff(retour->msg,"Unable to get server's address");
  2085.       return INVALID_SOCKET;
  2086.     }  
  2087.     // copie adresse
  2088.     SOCaddr_copyaddr(server, server_size, hp->h_addr_list[0], hp->h_length);
  2089.     // make a copy for external clients
  2090.     retour->address_size = sizeof(retour->address);
  2091.     SOCaddr_copyaddr(retour->address, retour->address_size, hp->h_addr_list[0], hp->h_length);
  2092.     // memcpy(&SOCaddr_sinaddr(server), hp->h_addr_list[0], hp->h_length);
  2093.      
  2094.     // crΘer ("attachement") une socket (point d'accΦs) internet,en flot
  2095. #if HDEBUG
  2096.     printf("socket\n");
  2097. #endif
  2098. #if HTS_WIDE_DEBUG    
  2099.     DEBUG_W("socket\n");
  2100. #endif
  2101.     soc=socket(SOCaddr_sinfamily(server), SOCK_STREAM, 0);
  2102.     if (retour != NULL) {
  2103.       retour->debugid = HTS_STAT.stat_sockid++;
  2104.     }
  2105. #if HTS_WIDE_DEBUG    
  2106.     DEBUG_W("socket()=%d\n" _ (int) soc);
  2107. #endif
  2108.     if (soc==INVALID_SOCKET) {
  2109.       if (retour)
  2110.       if (retour->msg)
  2111.         strcpybuff(retour->msg,"Unable to create a socket");
  2112.       return INVALID_SOCKET;                        // erreur crΘation socket impossible
  2113.     }
  2114.  
  2115.     // bind this address
  2116.     if (retour != NULL && retour->req.proxy.bindhost[0] != '\0') {
  2117.       t_fullhostent bind_buffer;
  2118.       hp = hts_gethostbyname(retour->req.proxy.bindhost, &bind_buffer);
  2119.       if (hp == NULL ||
  2120.         bind(soc, (struct sockaddr *)hp->h_addr_list[0], hp->h_length) != 0) {
  2121.         if (retour)
  2122.           if (retour->msg)
  2123.             strcpybuff(retour->msg,"Unable to bind the specificied server address");
  2124.           deletesoc(soc);
  2125.           return INVALID_SOCKET;
  2126.       }
  2127.     }
  2128.     
  2129.     // structure: connexion au domaine internet, port 80 (ou autre)
  2130.     SOCaddr_initport(server, port);
  2131. #if HDEBUG
  2132.     printf("==%d\n",soc);
  2133. #endif
  2134.  
  2135.     // connexion non bloquante?
  2136.     if (!waitconnect ) {
  2137.       unsigned long p=1;  // non bloquant
  2138. #if HTS_WIN
  2139.       ioctlsocket(soc,FIONBIO,&p);
  2140. #else
  2141.       ioctl(soc,FIONBIO,&p);
  2142. #endif
  2143.     }
  2144.     
  2145.     // Connexion au serveur lui mΩme
  2146. #if HDEBUG
  2147.     printf("connect\n");
  2148. #endif
  2149.     HTS_STAT.last_connect = mtime_local();
  2150.     
  2151. #if HTS_WIDE_DEBUG
  2152.     DEBUG_W("connect\n");
  2153. #endif
  2154. #if HTS_WIN
  2155.     if (connect(soc, (const struct sockaddr FAR *)&server, server_size) != 0) {
  2156. #else
  2157.       if (connect(soc, (struct sockaddr *)&server, server_size) == -1) {
  2158. #endif
  2159.  
  2160.         // bloquant
  2161.         if (waitconnect) {
  2162. #if HDEBUG
  2163.           printf("unable to connect!\n");
  2164. #endif
  2165.           if (retour)
  2166.           if (retour->msg)
  2167.             strcpybuff(retour->msg,"Unable to connect to the server");
  2168.           /* Close the socket and notify the error!!! */
  2169.           deletesoc(soc);
  2170.           return INVALID_SOCKET;
  2171.         }
  2172.       }
  2173. #if HTS_WIDE_DEBUG    
  2174.       DEBUG_W("connect done\n");
  2175. #endif
  2176.       
  2177. #if HDEBUG
  2178.       printf("connexion Θtablie\n");
  2179. #endif
  2180.     
  2181.     // A partir de maintenant, on peut envoyer et recevoir des donnΘes
  2182.     // via le flot identifiΘ par soc (socket): write(soc,adr,taille) et 
  2183.     // read(soc,adr,taille)
  2184.  
  2185.   } else {    // on doit ouvrir un fichier local!
  2186.     // il sera gΘrΘ de la mΩme maniΦre qu'une socket (c'est idem!)
  2187.  
  2188.     soc=LOCAL_SOCKET_ID;    // pseudo-socket locale..
  2189.     // soc sera remplacΘ lors d'un http_fopen() par un handle vΘritable!
  2190.  
  2191.   }   // teste fichier local ou http
  2192.   
  2193.   return soc;
  2194. }
  2195.  
  2196.  
  2197.  
  2198. // couper http://www.truc.fr/pub/index.html -> www.truc.fr /pub/index.html
  2199. // retour=-1 si erreur.
  2200. // si file://... alors adresse=file:// (et coupe le ?query dans ce cas)
  2201. int ident_url_absolute(char* url,char* adr,char* fil) {
  2202.   int pos=0;
  2203.   int scheme=0;
  2204.  
  2205.   // effacer adr et fil
  2206.   adr[0]=fil[0]='\0';
  2207.   
  2208. #if HDEBUG
  2209.   printf("protocol: %s\n",url);
  2210. #endif
  2211.  
  2212.   // Scheme?
  2213.   {
  2214.     char* a=url;
  2215.     while (isalpha((unsigned char)*a))
  2216.       a++;
  2217.     if (*a == ':')
  2218.       scheme=1;
  2219.   }
  2220.  
  2221.   // 1. optional scheme ":"
  2222.   if ((pos=strfield(url,"file:"))) {    // fichier local!! (pour les tests)
  2223.     //!!p+=3;
  2224.     strcpybuff(adr,"file://");
  2225.   } else if ((pos=strfield(url,"http:"))) {    // HTTP
  2226.     //!!p+=3;
  2227.   } else if ((pos=strfield(url,"ftp:"))) {    // FTP
  2228.     strcpybuff(adr,"ftp://");    // FTP!!
  2229.     //!!p+=3;
  2230. #if HTS_USEOPENSSL
  2231.   } else if (SSL_is_available && (pos=strfield(url,"https:"))) {    // HTTPS
  2232.     strcpybuff(adr,"https://");
  2233. #endif
  2234.   } else if (scheme) {
  2235.     return -1;    // erreur non reconnu
  2236.   } else
  2237.     pos=0;
  2238.  
  2239.   // 2. optional "//" authority
  2240.   if (strncmp(url+pos,"//",2)==0)
  2241.     pos+=2;
  2242.  
  2243.   // (url+pos) now points to the path (not net path)
  2244.  
  2245.   //## if (adr[0]!=lOCAL_CHAR) {    // adresse normale http
  2246.   if (!strfield(adr,"file:")) {      // PAS file://
  2247.     char *p,*q;
  2248.     p=url+pos;
  2249.  
  2250.     // p pointe sur le dΘbut de l'adresse, ex: www.truc.fr/sommaire/index.html
  2251.     q=strchr(jump_identification(p),'/');
  2252.     if (q==0) q=strchr(jump_identification(p),'?');     // http://www.foo.com?bar=1
  2253.     if (q==0) q=p+strlen(p);  // pointe sur \0
  2254.     // q pointe sur le chemin, ex: index.html?query=recherche
  2255.     
  2256.     // chemin www... trop long!!
  2257.     if ( ( ((int) (q - p)) )  > HTS_URLMAXSIZE) {
  2258.       //strcpybuff(retour.msg,"Path too long");
  2259.       return -1;    // erreur
  2260.     }
  2261.     
  2262.     // recopier adresse www..
  2263.     strncatbuff(adr,p, ((int) (q - p)) );
  2264.     // *( adr+( ((int) q) - ((int) p) ) )=0;  // faut arrΩter la fumette!
  2265.     // recopier chemin /pub/..
  2266.     if (q[0] != '/')    // page par dΘfaut (/)
  2267.       strcatbuff(fil,"/");
  2268.     strcatbuff(fil,q);
  2269.     // SECURITE:
  2270.     // simplifier url pour les ../
  2271.     fil_simplifie(fil);
  2272.   } else {    // localhost file://
  2273.     char *p;
  2274.     int i;
  2275.     char* a;
  2276.     
  2277.     p=url+pos;
  2278.     if (*p == '/' || *p == '\\') {  /* file:///.. */
  2279.       strcatbuff(fil,p);    // fichier local ; adr="#"
  2280.     } else {
  2281.       if (p[1] != ':') {
  2282.         strcatbuff(fil,"//");   /* file://server/foo */
  2283.         strcatbuff(fil,p);
  2284.       } else {
  2285.         strcatbuff(fil,p);    // file://C:\..
  2286.       }
  2287.     }
  2288.     
  2289.     a=strchr(fil,'?');
  2290.     if (a) 
  2291.       *a='\0';      /* couper query (inutile pour file:// lors de la requΩte) */
  2292.     // filtrer les \\ -> / pour les fichiers DOS
  2293.     for(i=0;i<(int) strlen(fil);i++)
  2294.       if (fil[i]=='\\')
  2295.         fil[i]='/';
  2296.   }
  2297.  
  2298.   // no hostname
  2299.   if (!strnotempty(adr))
  2300.     return -1;    // erreur non reconnu
  2301.  
  2302.   // nommer au besoin.. (non utilisΘ normalement)
  2303.   if (!strnotempty(fil))
  2304.     strcpybuff(fil,"default-index.html");
  2305.  
  2306.   // case insensitive pour adresse
  2307.   {
  2308.     char *a=jump_identification(adr);
  2309.     while(*a) {
  2310.       if ((*a>='A') && (*a<='Z'))
  2311.         *a+='a'-'A';       
  2312.       a++;
  2313.     }
  2314.   }
  2315.   
  2316.   return 0;
  2317. }
  2318.  
  2319. /* simplify ../ and ./ */
  2320. void fil_simplifie(char* f) {
  2321.   char *a, *b;
  2322.   char *rollback[128];
  2323.   int rollid = 0;
  2324.   char lc = '/';
  2325.   int query = 0;
  2326.   for(a = b = f ; *a != '\0' ; ) {
  2327.     if (*a == '?')
  2328.       query = 1;
  2329.     if (query == 0 && lc == '/' && a[0] == '.' && a[1] == '/') {    /* foo/./bar or ./foo  */
  2330.       a += 2;
  2331.     }
  2332.     else if (query == 0 && lc == '/' && a[0] == '.' && a[1] == '.' && a[2] == '/') {    /* foo/../bar or ../foo  */
  2333.       a += 3;
  2334.       if (rollid > 1) {
  2335.         rollid--;
  2336.         b = rollback[rollid - 1];
  2337.       } else {
  2338.         rollid = 0;
  2339.         b = f;
  2340.       }
  2341.     } else {
  2342.       *b++ = lc = *a;
  2343.       if (*a == '/') {
  2344.         rollback[rollid++] = b;
  2345.         if (rollid >= 127) {
  2346.           *f = '\0';      /* ERROR */
  2347.           break;
  2348.         }
  2349.       }
  2350.       a++;
  2351.     }
  2352.   }
  2353.   *b = '\0';
  2354.   if (*f == '\0') {
  2355.     f[0] = '.';
  2356.     f[1] = '/';
  2357.     f[2] = '\0';
  2358.   }
  2359. }
  2360.  
  2361. // fermer liaison fichier ou socket
  2362. HTS_INLINE void deletehttp(htsblk* r) {
  2363. #if HTS_DEBUG_CLOSESOCK
  2364.     DEBUG_W("deletehttp: (htsblk*) 0x%p\n" _ (void*) r);
  2365. #endif
  2366. #if HTS_USEOPENSSL
  2367.     /* Free OpenSSL structures */
  2368.     if (SSL_is_available && r->ssl_con) {
  2369.       SSL_shutdown(r->ssl_con);
  2370.       SSL_free(r->ssl_con);
  2371.       r->ssl_con=NULL;
  2372.     }
  2373. #endif  
  2374.   if (r->soc!=INVALID_SOCKET) {
  2375.     if (r->is_file) {
  2376.       if (r->fp)
  2377.         fclose(r->fp);
  2378.       r->fp=NULL;
  2379.     } else {
  2380.       if (r->soc!=LOCAL_SOCKET_ID)
  2381.         deletesoc_r(r);
  2382.     }
  2383.     r->soc=INVALID_SOCKET;
  2384.   }
  2385. }
  2386.  
  2387. // free the addr buffer
  2388. // always returns 1
  2389. HTS_INLINE int deleteaddr(htsblk* r) {
  2390.   if (r->adr != NULL) {
  2391.     freet(r->adr);
  2392.     r->adr = NULL;
  2393.   }
  2394.   if (r->headers != NULL) {
  2395.     freet(r->headers);
  2396.     r->headers = NULL;
  2397.   }
  2398.   return 1;
  2399. }
  2400.  
  2401. // fermer une socket
  2402. HTS_INLINE void deletesoc(T_SOC soc) {
  2403.   if (soc!=INVALID_SOCKET && soc!=LOCAL_SOCKET_ID) {
  2404. #if HTS_WIDE_DEBUG    
  2405.     DEBUG_W("close %d\n" _ (int) soc);
  2406. #endif
  2407. #if HTS_WIN
  2408.     closesocket(soc);
  2409. #else
  2410.     close(soc);
  2411. #endif
  2412. #if HTS_WIDE_DEBUG    
  2413.     DEBUG_W(".. done\n");
  2414. #endif
  2415.   }
  2416. }
  2417.  
  2418. /* Will also clean other things */
  2419. HTS_INLINE void deletesoc_r(htsblk* r) {
  2420. #if HTS_USEOPENSSL
  2421.   if (SSL_is_available && r->ssl_con) {
  2422.     SSL_shutdown(r->ssl_con);
  2423.     // SSL_CTX_set_quiet_shutdown(r->ssl_con->ctx, 1);
  2424.     SSL_free(r->ssl_con);
  2425.     r->ssl_con=NULL;
  2426.   }
  2427. #endif
  2428.   if (r->soc!=INVALID_SOCKET) {
  2429.     deletesoc(r->soc);
  2430.     r->soc=INVALID_SOCKET;
  2431.   }
  2432. }
  2433.  
  2434. // renvoi le nombre de secondes depuis 1970
  2435. HTS_INLINE TStamp time_local(void) {
  2436.   return ((TStamp) time(NULL));
  2437. }
  2438.  
  2439. // number of millisec since 1970
  2440. HTSEXT_API HTS_INLINE TStamp mtime_local(void) {
  2441. #ifndef HTS_DO_NOT_USE_FTIME
  2442.   struct timeb B;
  2443.   ftime( &B );
  2444.   return (TStamp) ( ((TStamp) B.time * (TStamp) 1000)
  2445.         + ((TStamp) B.millitm) );
  2446. #else
  2447.   // not precise..
  2448.   return (TStamp) ( ((TStamp) time_local() * (TStamp) 1000)
  2449.         + ((TStamp) 0) );
  2450. #endif
  2451. }
  2452.  
  2453. // convertit un nombre de secondes en temps (chaine)
  2454. void sec2str(char *st,TStamp t) {
  2455.   int j,h,m,s;
  2456.   
  2457.   j=(int) (t/(3600*24));
  2458.   t-=((TStamp) j)*(3600*24);
  2459.   h=(int) (t/(3600));
  2460.   t-=((TStamp) h)*3600;
  2461.   m=(int) (t/60);
  2462.   t-=((TStamp) m)*60;
  2463.   s=(int) t;
  2464.   
  2465.   if (j>0)
  2466.     sprintf(st,"%d days, %d hours %d minutes %d seconds",j,h,m,s);
  2467.   else if (h>0)
  2468.     sprintf(st,"%d hours %d minutes %d seconds",h,m,s);
  2469.   else if (m>0)
  2470.     sprintf(st,"%d minutes %d seconds",m,s);
  2471.   else
  2472.     sprintf(st,"%d seconds",s);
  2473. }
  2474.  
  2475. // idem, plus court (chaine)
  2476. HTSEXT_API void qsec2str(char *st,TStamp t) {
  2477.   int j,h,m,s;
  2478.   
  2479.   j=(int) (t/(3600*24));
  2480.   t-=((TStamp) j)*(3600*24);
  2481.   h=(int) (t/(3600));
  2482.   t-=((TStamp) h)*3600;
  2483.   m=(int) (t/60);
  2484.   t-=((TStamp) m)*60;
  2485.   s=(int) t;
  2486.   
  2487.   if (j>0)
  2488.     sprintf(st,"%dd,%02dh,%02dmin%02ds",j,h,m,s);
  2489.   else if (h>0)
  2490.     sprintf(st,"%dh,%02dmin%02ds",h,m,s);
  2491.   else if (m>0)
  2492.     sprintf(st,"%dmin%02ds",m,s);
  2493.   else
  2494.     sprintf(st,"%ds",s);
  2495. }
  2496.  
  2497.  
  2498. // heure actuelle, GMT, format rfc (taille buffer 256o)
  2499. void time_gmt_rfc822(char* s) {
  2500.   time_t tt;
  2501.   struct tm* A;
  2502.   tt=time(NULL);
  2503.   A=gmtime(&tt);
  2504.   if (A==NULL)
  2505.     A=localtime(&tt);
  2506.   time_rfc822(s,A);
  2507. }
  2508.  
  2509. // heure actuelle, format rfc (taille buffer 256o)
  2510. void time_local_rfc822(char* s) {
  2511.   time_t tt;
  2512.   struct tm* A;
  2513.   tt=time(NULL);
  2514.   A=localtime(&tt);
  2515.   time_rfc822_local(s,A);
  2516. }
  2517.  
  2518. /* convertir une chaine en temps */
  2519. struct tm* convert_time_rfc822(char* s) {
  2520.   struct tm* result;
  2521.   /* */
  2522.   char months[]="jan feb mar apr may jun jul aug sep oct nov dec";
  2523.   char str[256];
  2524.   char* a;
  2525.   /* */
  2526.   int result_mm=-1;
  2527.   int result_dd=-1;
  2528.   int result_n1=-1;
  2529.   int result_n2=-1;
  2530.   int result_n3=-1;
  2531.   int result_n4=-1;
  2532.   /* */
  2533.   NOSTATIC_RESERVE(result, struct tm, 1);
  2534.  
  2535.   if ((int) strlen(s) > 200)
  2536.     return NULL;
  2537.   strcpybuff(str,s);
  2538.   hts_lowcase(str);
  2539.   /* Θliminer :,- */
  2540.   while( (a=strchr(str,'-')) ) *a=' ';
  2541.   while( (a=strchr(str,':')) ) *a=' ';
  2542.   while( (a=strchr(str,',')) ) *a=' ';
  2543.   /* tokeniser */
  2544.   a=str;
  2545.   while(*a) {
  2546.     char *first,*last;
  2547.     char tok[256];
  2548.     /* dΘcouper mot */
  2549.     while(*a==' ') a++;   /* sauter espaces */
  2550.     first=a;
  2551.     while((*a) && (*a!=' ')) a++;
  2552.     last=a;
  2553.     tok[0]='\0';
  2554.     if (first!=last) {
  2555.       char* pos;
  2556.       strncatbuff(tok,first,(int) (last - first));
  2557.       /* analyser */
  2558.       if ( (pos=strstr(months,tok)) ) {               /* month always in letters */
  2559.         result_mm=((int) (pos - months))/4;
  2560.       } else {
  2561.         int number;
  2562.         if (sscanf(tok,"%d",&number) == 1) {      /* number token */
  2563.           if (result_dd<0)                        /* day always first number */
  2564.             result_dd=number;
  2565.           else if (result_n1<0)
  2566.             result_n1=number;
  2567.           else if (result_n2<0)
  2568.             result_n2=number;
  2569.           else if (result_n3<0)
  2570.             result_n3=number;
  2571.           else if (result_n4<0)
  2572.             result_n4=number;
  2573.         }   /* sinon, bruit de fond(+1GMT for exampel) */
  2574.       }
  2575.     }
  2576.   }
  2577.   if ((result_n1>=0) && (result_mm>=0) && (result_dd>=0) && (result_n2>=0) && (result_n3>=0) && (result_n4>=0)) {
  2578.     if (result_n4>=1000) {               /* Sun Nov  6 08:49:37 1994 */
  2579.       result->tm_year=result_n4-1900;
  2580.       result->tm_hour=result_n1;
  2581.       result->tm_min=result_n2;
  2582.       result->tm_sec=max(result_n3,0);
  2583.     } else {                            /* Sun, 06 Nov 1994 08:49:37 GMT or Sunday, 06-Nov-94 08:49:37 GMT */
  2584.       result->tm_hour=result_n2;
  2585.       result->tm_min=result_n3;
  2586.       result->tm_sec=max(result_n4,0);
  2587.       if (result_n1<=50)                /* 00 means 2000 */
  2588.         result->tm_year=result_n1+100;
  2589.       else if (result_n1<1000)          /* 99 means 1999 */
  2590.         result->tm_year=result_n1;
  2591.       else                              /* 2000 */
  2592.         result->tm_year=result_n1-1900;
  2593.     }
  2594.     result->tm_isdst=0;        /* assume GMT */
  2595.     result->tm_yday=-1;        /* don't know */
  2596.     result->tm_wday=-1;        /* don't know */
  2597.     result->tm_mon=result_mm;
  2598.     result->tm_mday=result_dd;
  2599.     return result;
  2600.   }
  2601.   return NULL;
  2602. }
  2603.  
  2604. /* sets file time. -1 if error */
  2605. int set_filetime(char* file,struct tm* tm_time) {
  2606.   struct utimbuf tim;
  2607. #ifndef HTS_DO_NOT_USE_FTIME
  2608.   struct timeb B;
  2609.   B.timezone=0;
  2610.   ftime( &B );
  2611.   tim.actime=tim.modtime=mktime(tm_time) - B.timezone*60; 
  2612. #else
  2613.   // bogus time (GMT/local)..
  2614.   tim.actime=tim.modtime=mktime(tm_time); 
  2615. #endif
  2616.   return utime(file,&tim);
  2617. }
  2618.  
  2619. /* sets file time from RFC822 date+time, -1 if error*/
  2620. int set_filetime_rfc822(char* file,char* date) {
  2621.   struct tm* tm_s=convert_time_rfc822(date);
  2622.   if (tm_s) {
  2623.     return set_filetime(file,tm_s);
  2624.   } else return -1;
  2625. }
  2626.  
  2627. int get_filetime_rfc822(char* file,char* date) {
  2628.   struct stat buf;
  2629.   date[0] = '\0';
  2630.   if (stat(file, &buf) == 0) {
  2631.     struct tm* A;
  2632.     time_t tt = buf.st_mtime;
  2633.     A=gmtime(&tt);
  2634.     if (A==NULL)
  2635.       A=localtime(&tt);
  2636.     time_rfc822(date, A);
  2637.     return 1;
  2638.   }
  2639.   return 0;
  2640. }
  2641.  
  2642. // heure au format rfc (taille buffer 256o)
  2643. HTS_INLINE void time_rfc822(char* s,struct tm * A) {
  2644.   if (A == NULL) {
  2645.     int localtime_returned_null=0;
  2646.     assert(localtime_returned_null);
  2647.   }
  2648.   strftime(s,256,"%a, %d %b %Y %H:%M:%S GMT",A);
  2649. }
  2650.  
  2651. // heure locale au format rfc (taille buffer 256o)
  2652. HTS_INLINE void time_rfc822_local(char* s,struct tm * A) {
  2653.   if (A == NULL) {
  2654.     int localtime_returned_null=0;
  2655.     assert(localtime_returned_null);
  2656.   }
  2657.   strftime(s,256,"%a, %d %b %Y %H:%M:%S",A);
  2658. }
  2659.  
  2660. // conversion en b,Kb,Mb
  2661. HTSEXT_API char* int2bytes(LLint n) {
  2662.   char** a=int2bytes2(n);
  2663.   char* buff;
  2664.   NOSTATIC_RESERVE(buff, char, 256);
  2665.  
  2666.   strcpybuff(buff,a[0]);
  2667.   strcatbuff(buff,a[1]);
  2668.   return concat(buff,"");
  2669. }
  2670.  
  2671. // conversion en b/s,Kb/s,Mb/s
  2672. HTSEXT_API char* int2bytessec(long int n) {
  2673.   char* buff;
  2674.   char** a=int2bytes2(n);
  2675.   NOSTATIC_RESERVE(buff, char, 256);
  2676.  
  2677.   strcpybuff(buff,a[0]);
  2678.   strcatbuff(buff,a[1]);
  2679.   return concat(buff,"/s");
  2680. }
  2681. HTSEXT_API char* int2char(int n) {
  2682.   char* buffer;
  2683.   NOSTATIC_RESERVE(buffer, char, 32);
  2684.   sprintf(buffer,"%d",n);
  2685.   return concat(buffer,"");
  2686. }
  2687.  
  2688. // conversion en b,Kb,Mb, nombre et type sΘparΘs
  2689. // limite: 2.10^9.10^6B
  2690.  
  2691. /* See http://physics.nist.gov/cuu/Units/binary.html */
  2692. #define ToLLint(a) ((LLint)(a))
  2693. #define ToLLintKiB (ToLLint(1024))
  2694. #define ToLLintMiB (ToLLintKiB*ToLLintKiB)
  2695. #ifdef HTS_LONGLONG
  2696. #define ToLLintGiB (ToLLintKiB*ToLLintKiB*ToLLintKiB)
  2697. #define ToLLintTiB (ToLLintKiB*ToLLintKiB*ToLLintKiB*ToLLintKiB)
  2698. #define ToLLintPiB (ToLLintKiB*ToLLintKiB*ToLLintKiB*ToLLintKiB*ToLLintKiB)
  2699. #endif
  2700. typedef struct {
  2701.   char buff1[256];
  2702.   char buff2[32];
  2703.   char* buffadr[2];
  2704. } strc_int2bytes2;
  2705. HTSEXT_API char** int2bytes2(LLint n) {
  2706.   strc_int2bytes2* strc;
  2707.   NOSTATIC_RESERVE(strc, strc_int2bytes2, 1);
  2708.  
  2709.   if (n < ToLLintKiB) {
  2710.     sprintf(strc->buff1,"%d",(int)(LLint)n);
  2711.     strcpybuff(strc->buff2,"B");
  2712.   } else if (n < ToLLintMiB) {
  2713.     sprintf(strc->buff1,"%d,%02d",(int)((LLint)(n/ToLLintKiB)),(int)((LLint)((n%ToLLintKiB)*100)/ToLLintKiB));
  2714.     strcpybuff(strc->buff2,"KiB");
  2715.   }
  2716. #ifdef HTS_LONGLONG
  2717.   else if (n < ToLLintGiB) {
  2718.     sprintf(strc->buff1,"%d,%02d",(int)((LLint)(n/(ToLLintMiB))),(int)((LLint)(((n%(ToLLintMiB))*100)/(ToLLintMiB))));
  2719.     strcpybuff(strc->buff2,"MiB");
  2720.   } else if (n < ToLLintTiB) {
  2721.     sprintf(strc->buff1,"%d,%02d",(int)((LLint)(n/(ToLLintGiB))),(int)((LLint)(((n%(ToLLintGiB))*100)/(ToLLintGiB))));
  2722.     strcpybuff(strc->buff2,"GiB");
  2723.   } else if (n < ToLLintPiB) {
  2724.     sprintf(strc->buff1,"%d,%02d",(int)((LLint)(n/(ToLLintTiB))),(int)((LLint)(((n%(ToLLintTiB))*100)/(ToLLintTiB))));
  2725.     strcpybuff(strc->buff2,"TiB");
  2726.   } else {
  2727.     sprintf(strc->buff1,"%d,%02d",(int)((LLint)(n/(ToLLintPiB))),(int)((LLint)(((n%(ToLLintPiB))*100)/(ToLLintPiB))));
  2728.     strcpybuff(strc->buff2,"PiB");
  2729.   }
  2730. #else
  2731.   else {
  2732.     sprintf(strc->buff1,"%d,%02d",(int)((LLint)(n/(ToLLintMiB))),(int)((LLint)(((n%(ToLLintMiB))*100)/(ToLLintMiB))));
  2733.     strcpybuff(strc->buff2,"MiB");
  2734.   }
  2735. #endif
  2736.   strc->buffadr[0]=strc->buff1;
  2737.   strc->buffadr[1]=strc->buff2;
  2738.   return strc->buffadr;
  2739. }
  2740.  
  2741. #if HTS_WIN
  2742. #else
  2743. // ignore sigpipe?
  2744. int sig_ignore_flag( int setflag ) {     // flag ignore
  2745.   static int flag=0;   /* YES, this one is true static */
  2746.   if (setflag>=0)
  2747.     flag=setflag;
  2748.   return flag;
  2749. }
  2750. #endif
  2751.  
  2752. // envoi de texte (en tΩtes gΘnΘralement) sur la socket soc
  2753. HTS_INLINE int sendc(htsblk* r, char* s) {
  2754.   int n, ssz = (int)strlen(s);
  2755.  
  2756. #if HTS_WIN
  2757. #else
  2758.   sig_ignore_flag(1);
  2759. #endif
  2760. #if HDEBUG
  2761.   write(0,s,ssz);
  2762. #endif
  2763.  
  2764. #if HTS_USEOPENSSL
  2765.   if (SSL_is_available && r->ssl) {
  2766.     n = SSL_write(r->ssl_con, s, ssz);
  2767.   } else
  2768. #endif
  2769.     n = send(r->soc,s,ssz,0);
  2770.  
  2771. #if HTS_WIN
  2772. #else
  2773.   sig_ignore_flag(0);
  2774. #endif
  2775.  
  2776.   return ( n == ssz ) ? n : -1;
  2777. }
  2778.  
  2779.  
  2780. // Remplace read
  2781. int finput(int fd,char* s,int max) {
  2782.   char c;
  2783.   int j=0;
  2784.   do {
  2785.     //c=fgetc(fp);
  2786.     if (read(fd,&c,1)<=0) {
  2787.       c=0;
  2788.     }
  2789.     if (c!=0) {
  2790.       switch(c) {
  2791.       case 10: c=0; break;
  2792.       case 13: break;  // sauter ces caractΦres
  2793.       default: s[j++]=c; break;
  2794.       }
  2795.     }
  2796.   }  while((c!=0) && (j<max-1));
  2797.   s[j]='\0';
  2798.   return j;
  2799. } 
  2800.  
  2801. // Like linput, but in memory (optimized)
  2802. int binput(char* buff, char* s, int max) {
  2803.   int count = 0;
  2804.   int destCount = 0;
  2805.  
  2806.   // Note: \0 will return 1
  2807.   while(count < max && buff != NULL && buff[count] != '\0' && buff[count] != '\n') {
  2808.     if (buff[count] != '\r') {
  2809.       s[destCount++] = buff[count];
  2810.     }
  2811.     count++;
  2812.   }
  2813.   s[destCount] = '\0';
  2814.  
  2815.   // then return the supplemental jump offset
  2816.   return count + 1;
  2817. } 
  2818.  
  2819. // Lecture d'une ligne (peut Ωtre unicode α priori)
  2820. int linput(FILE* fp,char* s,int max) {
  2821.   int c;
  2822.   int j=0;
  2823.   do {
  2824.     c=fgetc(fp);
  2825.     if (c!=EOF) {
  2826.       switch(c) {
  2827.         case 13: break;  // sauter CR
  2828.         case 10: c=-1; break;
  2829.         case 9: case 12: break;  // sauter ces caractΦres
  2830.         default: s[j++]=(char) c; break;
  2831.       }
  2832.     }
  2833.   }  while((c!=-1) && (c!=EOF) && (j<(max-1)));
  2834.   s[j]='\0';
  2835.   return j;
  2836. }
  2837. int linputsoc(T_SOC soc, char* s, int max) {
  2838.   int c;
  2839.   int j=0;
  2840.   do {
  2841.     unsigned char ch;
  2842.     if (recv(soc, &ch, 1, 0) == 1) {
  2843.       c = ch;
  2844.     } else {
  2845.       c = EOF;
  2846.     }
  2847.     if (c!=EOF) {
  2848.       switch(c) {
  2849.         case 13: break;  // sauter CR
  2850.         case 10: c=-1; break;
  2851.         case 9: case 12: break;  // sauter ces caractΦres
  2852.         default: s[j++]=(char) c; break;
  2853.       }
  2854.     }
  2855.   }  while((c!=-1) && (c!=EOF) && (j<(max-1)));
  2856.   s[j]='\0';
  2857.   return j;
  2858. }
  2859. int linputsoc_t(T_SOC soc, char* s, int max, int timeout) {
  2860.   if (check_readinput_t(soc, timeout)) {
  2861.     return linputsoc(soc, s, max);
  2862.   }
  2863.   return -1;
  2864. }
  2865. int linput_trim(FILE* fp,char* s,int max) {
  2866.   int rlen=0;
  2867.   char* ls=(char*) malloct(max+2);
  2868.   s[0]='\0';
  2869.   if (ls) {
  2870.     char* a;
  2871.     // lire ligne
  2872.     rlen=linput(fp,ls,max);
  2873.     if (rlen) {
  2874.       // sauter espaces et tabs en fin
  2875.       while( (rlen>0) && ((ls[max(rlen-1,0)]==' ') || (ls[max(rlen-1,0)]=='\t')) )
  2876.         ls[--rlen]='\0';
  2877.       // sauter espaces en dΘbut
  2878.       a=ls;
  2879.       while((rlen>0) && ((*a==' ') || (*a=='\t'))) {
  2880.         a++;
  2881.         rlen--;
  2882.       }
  2883.       if (rlen>0) {
  2884.         memcpy(s,a,rlen);      // can copy \0 chars
  2885.         s[rlen]='\0';
  2886.       }
  2887.     }
  2888.     //
  2889.     freet(ls);
  2890.   }
  2891.   return rlen;
  2892. }
  2893. int linput_cpp(FILE* fp,char* s,int max) {
  2894.   int rlen=0;
  2895.   s[0]='\0';
  2896.   do {
  2897.     int ret;
  2898.     if (rlen>0)
  2899.     if (s[rlen-1]=='\\')
  2900.       s[--rlen]='\0';      // couper \ final
  2901.     // lire ligne
  2902.     ret=linput_trim(fp,s+rlen,max-rlen);
  2903.     if (ret>0)
  2904.       rlen+=ret;
  2905.   } while((s[max(rlen-1,0)]=='\\') && (rlen<max));
  2906.   return rlen;
  2907. }
  2908.  
  2909. // idem avec les car spΘciaux
  2910. void rawlinput(FILE* fp,char* s,int max) {
  2911.   int c;
  2912.   int j=0;
  2913.   do {
  2914.     c=fgetc(fp);
  2915.     if (c!=EOF) {
  2916.       switch(c) {
  2917.         case 13: break;  // sauter CR
  2918.         case 10: c=-1; break;
  2919.         default: s[j++]=(char) c; break;
  2920.       }
  2921.     }
  2922.   }  while((c!=-1) && (c!=EOF) && (j<(max-1)));
  2923.   s[j++]='\0';
  2924. }
  2925.  
  2926. //cherche chaine, case insensitive
  2927. char* strstrcase(char *s,char *o) {
  2928.   while((*s) && (strfield(s,o)==0)) s++;
  2929.   if (*s=='\0') return NULL;
  2930.   return s;  
  2931. }
  2932.  
  2933.  
  2934. // Unicode detector
  2935. // See http://www.unicode.org/unicode/reports/tr28/
  2936. // (sect Table 3.1B. Legal UTF-8 Byte Sequences)
  2937. typedef struct {
  2938.   unsigned int pos;
  2939.   unsigned char data[4];
  2940. } t_auto_seq;
  2941.  
  2942. // char between a and b
  2943. #define CHAR_BETWEEN(c, a, b)       ( (c) >= 0x##a ) && ( (c) <= 0x##b )
  2944. // sequence start
  2945. #define SEQBEG                      ( inseq == 0 )
  2946. // in this block
  2947. #define BLK(n,a, b)                 ( (seq.pos >= n) && ((err = CHAR_BETWEEN(seq.data[n], a, b))) )
  2948. #define ELT(n,a)                    BLK(n,a,a)
  2949. // end
  2950. #define SEQEND                      ((ok = 1))
  2951. // sequence started, character will fail if error
  2952. #define IN_SEQ                      ( (inseq = 1) )
  2953. // decoding error
  2954. #define BAD_SEQ                     ( (ok == 0) && (inseq != 0) && (!err) )
  2955. // no sequence started
  2956. #define NO_SEQ                      ( inseq == 0 )
  2957.  
  2958. // is this block an UTF unicode textfile?
  2959. // 0 : no
  2960. // 1 : yes
  2961. // -1: don't know
  2962. int is_unicode_utf8(unsigned char* buffer, unsigned int size) {
  2963.   t_auto_seq seq;
  2964.   unsigned int i;
  2965.   int is_utf=-1;
  2966.  
  2967.   seq.pos=0;
  2968.   for(i=0 ; i < size ; i++) {
  2969.     unsigned int ok=0;
  2970.     unsigned int inseq=0;
  2971.     unsigned int err=0;
  2972.  
  2973.     seq.data[seq.pos]=buffer[i];
  2974.     /**/ if ( SEQBEG && BLK(0,00,7F) && IN_SEQ && SEQEND                                                 ) { }
  2975.     else if ( SEQBEG && BLK(0,C2,DF) && IN_SEQ && BLK(1,80,BF) && SEQEND                                 ) { }
  2976.     else if ( SEQBEG && ELT(0,E0   ) && IN_SEQ && BLK(1,A0,BF) && BLK(2,80,BF) && SEQEND                 ) { }
  2977.     else if ( SEQBEG && BLK(0,E1,EC) && IN_SEQ && BLK(1,80,BF) && BLK(2,80,BF) && SEQEND                 ) { }
  2978.     else if ( SEQBEG && ELT(0,ED   ) && IN_SEQ && BLK(1,80,9F) && BLK(2,80,BF) && SEQEND                 ) { }
  2979.     else if ( SEQBEG && BLK(0,EE,EF) && IN_SEQ && BLK(1,80,BF) && BLK(2,80,BF) && SEQEND                 ) { }
  2980.     else if ( SEQBEG && ELT(0,F0   ) && IN_SEQ && BLK(1,90,BF) && BLK(2,80,BF) && BLK(3,80,BF) && SEQEND ) { }
  2981.     else if ( SEQBEG && BLK(0,F1,F3) && IN_SEQ && BLK(1,80,BF) && BLK(2,80,BF) && BLK(3,80,BF) && SEQEND ) { }
  2982.     else if ( SEQBEG && ELT(0,F4   ) && IN_SEQ && BLK(1,80,8F) && BLK(2,80,BF) && BLK(3,80,BF) && SEQEND ) { }
  2983.     else if ( NO_SEQ ) {    // bad, unknown
  2984.       return 0;
  2985.     }
  2986.     /* */
  2987.     
  2988.     /* Error */
  2989.     if ( BAD_SEQ ) {
  2990.       return 0;
  2991.     }
  2992.  
  2993.     /* unicode character */
  2994.     if (seq.pos > 0)
  2995.       is_utf=1;
  2996.  
  2997.     /* Next */
  2998.     if (ok)
  2999.       seq.pos=0;
  3000.     else
  3001.       seq.pos++;
  3002.  
  3003.     /* Internal error */
  3004.     if (seq.pos >= 4)
  3005.       return 0;
  3006.  
  3007.   }
  3008.  
  3009.   return is_utf;
  3010. }
  3011.  
  3012. void map_characters(unsigned char* buffer, unsigned int size, unsigned int* map) {
  3013.   unsigned int i;
  3014.   memset(map, 0, sizeof(unsigned int) * 256);
  3015.   for(i = 0 ; i < size ; i++) {
  3016.     map[buffer[i]]++;
  3017.   }
  3018. }
  3019.  
  3020.  
  3021. // le fichier est-il un fichier html?
  3022. //  0 : non
  3023. //  1 : oui
  3024. // -1 : on sait pas
  3025. // -2 : on sait pas, pas d'extension
  3026. int ishtml(const char* fil) {
  3027.   const char *a;
  3028.  
  3029.   // patch pour les truc.html?Choix=toto
  3030.   if ( (a=strchr(fil,'?')) )  // paramΦtres?
  3031.     a--;  // pointer juste avant le ?
  3032.   else
  3033.     a=fil+strlen(fil)-1;  // pointer sur le dernier caractΦre
  3034.  
  3035.   if (*a=='/') return -1;    // rΘpertoire, on sait pas!!
  3036.   //if (*a=='/') return 1;    // ok rΘpertoire, html
  3037.  
  3038.   while ( (*a!='.') && (*a!='/')  && ( a > fil)) a--;
  3039.   if (*a=='.') {  // a une extension
  3040.     char BIGSTK fil_noquery[HTS_URLMAXSIZE*2];
  3041.     char* b;
  3042.     fil_noquery[0]='\0';
  3043.     a++;  // pointer sur extension
  3044.     strncatbuff(fil_noquery,a,HTS_URLMAXSIZE);
  3045.     b=strchr(fil_noquery,'?');
  3046.     if (b)
  3047.       *b='\0';
  3048.     return ishtml_ext(fil_noquery);     // retour
  3049.   } else return -2;   // indΘterminΘ, par exemple /truc
  3050. }
  3051.  
  3052. // idem, mais pour uniquement l'extension
  3053. int ishtml_ext(const char* a) {
  3054.   int html=0;  
  3055.   //
  3056.   if (strfield2(a,"html"))       html = 1;
  3057.   else if (strfield2(a,"htm"))   html = 1;
  3058.   else if (strfield2(a,"shtml")) html = 1;
  3059.   else if (strfield2(a,"phtml")) html = 1;
  3060.   else if (strfield2(a,"htmlx")) html = 1;
  3061.   else if (strfield2(a,"shtm"))  html = 1;
  3062.   else if (strfield2(a,"phtm"))  html = 1;
  3063.   else if (strfield2(a,"htmx"))  html = 1;
  3064.   //
  3065.   // insuccΦs..
  3066.   else {
  3067.     switch(is_knowntype(a)) {
  3068.     case 1:
  3069.       html = 0;     // connu, non html
  3070.       break;
  3071.     case 2:
  3072.       html = 1;     // connu, html
  3073.       break;
  3074.     default:
  3075.       html = -1;    // inconnu..
  3076.       break;
  3077.     }
  3078.   }
  3079.   return html;  
  3080. }
  3081.  
  3082. // error (404,500..)
  3083. HTS_INLINE int ishttperror(int err) {
  3084.   switch (err/100) {
  3085.     case 4: case 5: return 1;
  3086.       break;
  3087.   }
  3088.   return 0;
  3089. }
  3090.  
  3091.  
  3092. // retourne le pointeur ou le pointeur + offset si il existe dans la chaine un @ signifiant 
  3093. // une identification
  3094. HTSEXT_API char* jump_identification(char* source) {
  3095.   char *a,*trytofind;
  3096.   if (strcmp(source, "file://") == 0)
  3097.       return source;
  3098.   // rechercher dernier @ (car parfois email transmise dans adresse!)
  3099.   // mais sauter ftp:// Θventuel
  3100.   a = jump_protocol(source);
  3101.   trytofind = strrchr_limit(a, '@', strchr(a,'/'));
  3102.   return (trytofind != NULL)?trytofind:a;
  3103. }
  3104.  
  3105. HTSEXT_API char* jump_normalized(char* source) {
  3106.   if (strcmp(source, "file://") == 0)
  3107.       return source;
  3108.   source = jump_identification(source); 
  3109.   if (strfield(source, "www") && source[3] != '\0') {
  3110.     if (source[3] == '.') {       // www.foo.com -> foo.com
  3111.       source += 4;  
  3112.     } else {                      // www-4.foo.com -> foo.com
  3113.       char* a = source + 3;
  3114.       while(*a && ( isdigit(*a) || *a == '-') ) a++;
  3115.       if (*a == '.') {
  3116.         source = a + 1;
  3117.       }
  3118.     }
  3119.   }
  3120.   return source;  
  3121. }
  3122.  
  3123. static int sortNormFnc(const void * a_, const void * b_) {
  3124.   char** a = (char**) a_;
  3125.   char** b = (char**) b_;
  3126.   return strcmp(*a+1, *b+1);
  3127. }
  3128.  
  3129.  
  3130. HTSEXT_API char* fil_normalized(char* source, char* dest) {
  3131.   char lastc = 0;
  3132.   int gotquery=0;
  3133.   int ampargs=0;
  3134.   int i,j;
  3135.   char* query=NULL;
  3136.   for(i=j=0 ; source[i] != '\0'; i++) {
  3137.     if (!gotquery && source[i] == '?')
  3138.       gotquery=ampargs=1;
  3139.     if ( 
  3140.       (!gotquery && lastc == '/' && source[i] == '/')  // foo//bar -> foo/bar
  3141.       ) {
  3142.     }
  3143.     else {
  3144.       if (gotquery && source[i] == '&') {
  3145.         ampargs++;
  3146.       }
  3147.       dest[j++] = source[i];
  3148.     }
  3149.     lastc = source[i];
  3150.   }
  3151.   dest[j++] = '\0';
  3152.  
  3153.   /* Sort arguments (&foo=1&bar=2 == &bar=2&foo=1) */
  3154.   if (ampargs > 1) {
  3155.     char** amps = malloct(ampargs * sizeof(char*));
  3156.     char* copyBuff = NULL;
  3157.     int qLen=0;
  3158.     assertf(amps != NULL);
  3159.     gotquery = 0;
  3160.     for(i=j=0 ; dest[i] != '\0'; i++) {
  3161.       if ( (gotquery && dest[i] == '&') || ( !gotquery && dest[i] == '?') ) {
  3162.         if (!gotquery) {
  3163.           gotquery=1;
  3164.           query = &dest[i];
  3165.           qLen = (int)strlen(query);
  3166.         }
  3167.         assertf(j < ampargs);
  3168.         amps[j++] = &dest[i];
  3169.         dest[i] = '\0';
  3170.       }
  3171.     }
  3172.     assertf(j == ampargs);
  3173.  
  3174.     /* Sort 'em all */
  3175.     qsort(amps, ampargs, sizeof(char*), sortNormFnc);
  3176.  
  3177.     /* Replace query by sorted query */
  3178.     copyBuff = malloct(qLen + 1);
  3179.     assertf(copyBuff != NULL);
  3180.     copyBuff[0] = '\0';
  3181.     for(i = 0 ; i < ampargs ; i++) {
  3182.       if (i == 0)
  3183.         strcatbuff(copyBuff, "?");
  3184.       else
  3185.         strcatbuff(copyBuff, "&");
  3186.       strcatbuff(copyBuff, amps[i] + 1);
  3187.     }
  3188.     assert((int)strlen(copyBuff) <= qLen);
  3189.     strcpybuff(query, copyBuff);
  3190.  
  3191.     /* Cleanup */
  3192.     freet(amps);
  3193.     freet(copyBuff);
  3194.   }
  3195.   
  3196.   return dest;
  3197. }
  3198.  
  3199. #define endwith(a) ( (len >= (sizeof(a)-1)) ? ( strncmp(dest, a+len-(sizeof(a)-1), sizeof(a)-1) == 0 ) : 0 );
  3200. HTSEXT_API char* adr_normalized(char* source, char* dest) {
  3201.   /* not yet too aggressive (no com<->net<->org checkings) */
  3202.   strcpybuff(dest, jump_normalized(source));
  3203.   return dest;
  3204. }
  3205. #undef endwith
  3206.  
  3207.  
  3208. // find port (:80) or NULL if not found
  3209. // can handle IPV6 addresses
  3210. HTSEXT_API char* jump_toport(char* source) {
  3211.   char *a,*trytofind;
  3212.   a = jump_identification(source);
  3213.   trytofind = strrchr_limit(a, ']', strchr(source, '/'));    // find last ] (http://[3ffe:b80:1234::1]:80/foo.html)
  3214.   a = strchr( (trytofind)?trytofind:a, ':');
  3215.   return a;
  3216. }
  3217.  
  3218. // strrchr, but not too far
  3219. char* strrchr_limit(char* s, char c, char* limit) {
  3220.   if (limit == NULL) {
  3221.     char* p = strrchr(s, c);
  3222.     return p?(p+1):NULL;
  3223.   } else {
  3224.     char *a=NULL, *p;
  3225.     for(;;) {
  3226.       p=strchr((a)?a:s, c);
  3227.       if ((p >= limit) || (p == NULL))
  3228.         return a;
  3229.       a=p+1;
  3230.     }
  3231.   }
  3232. }
  3233.  
  3234. // strrchr, but not too far
  3235. char* strstr_limit(char* s, char* sub, char* limit) {
  3236.   if (limit == NULL) {
  3237.     return strstr(s, sub);
  3238.   } else {
  3239.     char* pos = strstr(s, sub);
  3240.     if (pos != NULL) {
  3241.       char* farpos = strstr(s, limit);
  3242.       if (farpos == NULL || pos < farpos)
  3243.         return pos;
  3244.     }
  3245.   }
  3246.   return NULL;
  3247. }
  3248.  
  3249. // retourner adr sans ftp://
  3250. HTS_INLINE char* jump_protocol(char* source) {
  3251.   int p;
  3252.   // scheme
  3253.   // "Comparisons of scheme names MUST be case-insensitive" (RFC2616)
  3254.   if ((p=strfield(source,"http:")))
  3255.     source+=p;
  3256.   else if ((p=strfield(source,"ftp:")))
  3257.     source+=p;
  3258.   else if ((p=strfield(source,"https:")))
  3259.     source+=p;
  3260.   else if ((p=strfield(source,"file:")))
  3261.     source+=p;
  3262.   // net_path
  3263.   if (strncmp(source,"//",2)==0)
  3264.     source+=2;
  3265.   return source;
  3266. }
  3267.  
  3268. // codage base 64 a vers b
  3269. void code64(unsigned char* a,int size_a,unsigned char* b,int crlf) {
  3270.   int i1=0,i2=0,i3=0,i4=0;
  3271.   int loop=0;
  3272.   unsigned long int store;
  3273.   int n;
  3274.   const char _hts_base64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  3275.   while(size_a-- > 0) {  
  3276.     // 24 bits
  3277.     n=1; 
  3278.     store = *a++;
  3279.     if (size_a-- > 0) { n=2; store <<= 8; store |= *a++; }
  3280.     if (size_a-- > 0) { n=3; store <<= 8; store |= *a++; }
  3281.     if (n==3) {
  3282.       i4=store & 63;
  3283.       i3=(store>>6) & 63;
  3284.       i2=(store>>12) & 63;
  3285.       i1=(store>>18) & 63;
  3286.     } else if (n==2) {
  3287.       store<<=2;    
  3288.       i3=store & 63;
  3289.       i2=(store>>6) & 63;
  3290.       i1=(store>>12) & 63;
  3291.     } else {
  3292.       store<<=4;
  3293.       i2=store & 63;
  3294.       i1=(store>>6) & 63;
  3295.     }
  3296.     
  3297.     *b++ = _hts_base64[i1];
  3298.     *b++ = _hts_base64[i2];
  3299.     if (n>=2)
  3300.       *b++ = _hts_base64[i3];
  3301.     else
  3302.       *b++ = '=';
  3303.     if (n>=3)
  3304.       *b++ = _hts_base64[i4];
  3305.     else
  3306.       *b++ = '=';
  3307.  
  3308.     if (crlf && ( ( loop += 3 ) % 60) == 0 ) {
  3309.       *b++ = '\r';
  3310.       *b++ = '\n';
  3311.     }
  3312.   }
  3313.   *b++='\0';
  3314. }
  3315.  
  3316. // remplacer " par " etc..
  3317. // buffer MAX 1Ko
  3318. #define strcmpbeg(a, b) strncmp(a, b, strlen(b))
  3319. HTSEXT_API void unescape_amp(char* s) {
  3320.   while(*s) {
  3321.     if (*s=='&') {
  3322.       char* end=strchr(s,';');
  3323.       if ( end && (((int) (end - s)) <= 8) ) {
  3324.         unsigned char c=0;
  3325.         
  3326.         // http://www.w3.org/TR/xhtml-modularization/dtd_module_defs.html
  3327.         if (strcmpbeg(s, "&#") == 0) {
  3328.           int num=0;
  3329.           if ( (s[2] == 'x') || (s[2] == 'X')) {
  3330.             if (sscanf(s+3, "%x", &num) == 1) {
  3331.               c=(unsigned char)num;
  3332.             }
  3333.           } else {
  3334.             if (sscanf(s+2, "%d", &num) == 1) {
  3335.               c=(unsigned char)num;
  3336.             }
  3337.           }
  3338.         } else if (strcmpbeg(s, " ")==0)
  3339.           c=32; // hack - c=160;
  3340.         else if (strcmpbeg(s, "¡")==0)
  3341.           c=161;
  3342.         else if (strcmpbeg(s, "¢")==0)
  3343.           c=162;
  3344.         else if (strcmpbeg(s, "£")==0)
  3345.           c=163;
  3346.         else if (strcmpbeg(s, "¤")==0)
  3347.           c=164;
  3348.         else if (strcmpbeg(s, "¥")==0)
  3349.           c=165;
  3350.         else if (strcmpbeg(s, "¦")==0)
  3351.           c=166;
  3352.         else if (strcmpbeg(s, "§")==0)
  3353.           c=167;
  3354.         else if (strcmpbeg(s, "¨")==0)
  3355.           c=168;
  3356.         else if (strcmpbeg(s, "©")==0)
  3357.           c=169;
  3358.         else if (strcmpbeg(s, "ª")==0)
  3359.           c=170;
  3360.         //else if (strcmpbeg(s, "«")==0)
  3361.         //  c=171;
  3362.         else if (strcmpbeg(s, "¬")==0)
  3363.           c=172;
  3364.         //else if (strcmpbeg(s, "­")==0)
  3365.         //  c=173;
  3366.         else if (strcmpbeg(s, "®")==0)
  3367.           c=174;
  3368.         else if (strcmpbeg(s, "¯")==0)
  3369.           c=175;
  3370.         else if (strcmpbeg(s, "°")==0)
  3371.           c=176;
  3372.         else if (strcmpbeg(s, "±")==0)
  3373.           c=177;
  3374.         else if (strcmpbeg(s, "²")==0)
  3375.           c=178;
  3376.         else if (strcmpbeg(s, "³")==0)
  3377.           c=179;
  3378.         else if (strcmpbeg(s, "´")==0)
  3379.           c=180;
  3380.         else if (strcmpbeg(s, "µ")==0)
  3381.           c=181;
  3382.         else if (strcmpbeg(s, "¶")==0)
  3383.           c=182;
  3384.         else if (strcmpbeg(s, "·")==0)
  3385.           c=183;
  3386.         else if (strcmpbeg(s, "¸")==0)
  3387.           c=184;
  3388.         else if (strcmpbeg(s, "¹")==0)
  3389.           c=185;
  3390.         else if (strcmpbeg(s, "º")==0)
  3391.           c=186;
  3392.         //else if (strcmpbeg(s, "»")==0)
  3393.         //  c=187;
  3394.         else if (strcmpbeg(s, "¼")==0)
  3395.           c=188;
  3396.         else if (strcmpbeg(s, "½")==0)
  3397.           c=189;
  3398.         else if (strcmpbeg(s, "¾")==0)
  3399.           c=190;
  3400.         else if (strcmpbeg(s, "¿")==0)
  3401.           c=191;
  3402.         else if (strcmpbeg(s, "À")==0)
  3403.           c=192;
  3404.         else if (strcmpbeg(s, "Á")==0)
  3405.           c=193;
  3406.         else if (strcmpbeg(s, "Â")==0)
  3407.           c=194;
  3408.         else if (strcmpbeg(s, "Ã")==0)
  3409.           c=195;
  3410.         else if (strcmpbeg(s, "Ä")==0)
  3411.           c=196;
  3412.         else if (strcmpbeg(s, "Å")==0)
  3413.           c=197;
  3414.         else if (strcmpbeg(s, "Æ")==0)
  3415.           c=198;
  3416.         else if (strcmpbeg(s, "Ç")==0)
  3417.           c=199;
  3418.         else if (strcmpbeg(s, "È")==0)
  3419.           c=200;
  3420.         else if (strcmpbeg(s, "É")==0)
  3421.           c=201;
  3422.         else if (strcmpbeg(s, "Ê")==0)
  3423.           c=202;
  3424.         else if (strcmpbeg(s, "Ë")==0)
  3425.           c=203;
  3426.         else if (strcmpbeg(s, "Ì")==0)
  3427.           c=204;
  3428.         else if (strcmpbeg(s, "Í")==0)
  3429.           c=205;
  3430.         else if (strcmpbeg(s, "Î")==0)
  3431.           c=206;
  3432.         else if (strcmpbeg(s, "Ï")==0)
  3433.           c=207;
  3434.         else if (strcmpbeg(s, "Ð")==0)
  3435.           c=208;
  3436.         else if (strcmpbeg(s, "Ñ")==0)
  3437.           c=209;
  3438.         else if (strcmpbeg(s, "Ò")==0)
  3439.           c=210;
  3440.         else if (strcmpbeg(s, "Ó")==0)
  3441.           c=211;
  3442.         else if (strcmpbeg(s, "Ô")==0)
  3443.           c=212;
  3444.         else if (strcmpbeg(s, "Õ")==0)
  3445.           c=213;
  3446.         else if (strcmpbeg(s, "Ö")==0)
  3447.           c=214;
  3448.         else if (strcmpbeg(s, "×")==0)
  3449.           c=215;
  3450.         else if (strcmpbeg(s, "Ø")==0)
  3451.           c=216;
  3452.         else if (strcmpbeg(s, "Ù")==0)
  3453.           c=217;
  3454.         else if (strcmpbeg(s, "Ú")==0)
  3455.           c=218;
  3456.         else if (strcmpbeg(s, "Û")==0)
  3457.           c=219;
  3458.         else if (strcmpbeg(s, "Ü")==0)
  3459.           c=220;
  3460.         else if (strcmpbeg(s, "Ý")==0)
  3461.           c=221;
  3462.         else if (strcmpbeg(s, "Þ")==0)
  3463.           c=222;
  3464.         else if (strcmpbeg(s, "ß")==0)
  3465.           c=223;
  3466.         else if (strcmpbeg(s, "à")==0)
  3467.           c=224;
  3468.         else if (strcmpbeg(s, "á")==0)
  3469.           c=225;
  3470.         else if (strcmpbeg(s, "â")==0)
  3471.           c=226;
  3472.         else if (strcmpbeg(s, "ã")==0)
  3473.           c=227;
  3474.         else if (strcmpbeg(s, "ä")==0)
  3475.           c=228;
  3476.         else if (strcmpbeg(s, "å")==0)
  3477.           c=229;
  3478.         else if (strcmpbeg(s, "æ")==0)
  3479.           c=230;
  3480.         else if (strcmpbeg(s, "ç")==0)
  3481.           c=231;
  3482.         else if (strcmpbeg(s, "è")==0)
  3483.           c=232;
  3484.         else if (strcmpbeg(s, "é")==0)
  3485.           c=233;
  3486.         else if (strcmpbeg(s, "ê")==0)
  3487.           c=234;
  3488.         else if (strcmpbeg(s, "ë")==0)
  3489.           c=235;
  3490.         else if (strcmpbeg(s, "ì")==0)
  3491.           c=236;
  3492.         else if (strcmpbeg(s, "í")==0)
  3493.           c=237;
  3494.         else if (strcmpbeg(s, "î")==0)
  3495.           c=238;
  3496.         else if (strcmpbeg(s, "ï")==0)
  3497.           c=239;
  3498.         else if (strcmpbeg(s, "ð")==0)
  3499.           c=240;
  3500.         else if (strcmpbeg(s, "ñ")==0)
  3501.           c=241;
  3502.         else if (strcmpbeg(s, "ò")==0)
  3503.           c=242;
  3504.         else if (strcmpbeg(s, "ó")==0)
  3505.           c=243;
  3506.         else if (strcmpbeg(s, "ô")==0)
  3507.           c=244;
  3508.         else if (strcmpbeg(s, "õ")==0)
  3509.           c=245;
  3510.         else if (strcmpbeg(s, "ö")==0)
  3511.           c=246;
  3512.         else if (strcmpbeg(s, "÷")==0)
  3513.           c=247;
  3514.         else if (strcmpbeg(s, "ø")==0)
  3515.           c=248;
  3516.         else if (strcmpbeg(s, "ù")==0)
  3517.           c=249;
  3518.         else if (strcmpbeg(s, "ú")==0)
  3519.           c=250;
  3520.         else if (strcmpbeg(s, "û")==0)
  3521.           c=251;
  3522.         else if (strcmpbeg(s, "ü")==0)
  3523.           c=252;
  3524.         else if (strcmpbeg(s, "ý")==0)
  3525.           c=253;
  3526.         else if (strcmpbeg(s, "þ")==0)
  3527.           c=254;
  3528.         else if (strcmpbeg(s, "ÿ")==0)
  3529.           c=255;
  3530.         //        
  3531.         else if (strcmpbeg(s,"&")==0)
  3532.           c='&';
  3533.         else if (strcmpbeg(s,">")==0)
  3534.           c='>';
  3535.         else if (strcmpbeg(s,"«")==0)
  3536.           c='\"';
  3537.         else if (strcmpbeg(s,"<")==0)
  3538.           c='<';
  3539.         else if (strcmpbeg(s," ")==0)
  3540.           c=' ';
  3541.         else if (strcmpbeg(s,""")==0)
  3542.           c='\"';
  3543.         else if (strcmpbeg(s,"»")==0)
  3544.           c='\"';
  3545.         else if (strcmpbeg(s,"­")==0)
  3546.           c='-';
  3547.         else if (strcmpbeg(s,"˜")==0)
  3548.           c='~';
  3549.         // remplacer?
  3550.         if (c) {
  3551.           char BIGSTK buff[HTS_URLMAXSIZE*2];
  3552.           buff[0]=(char) c;
  3553.           strcpybuff(buff+1,end+1);
  3554.           strcpybuff(s,buff);
  3555.         }
  3556.       }
  3557.     }
  3558.     s++;
  3559.   }
  3560. }
  3561.  
  3562. static int ehexh(char c) {
  3563.   if ((c>='0') && (c<='9')) return c-'0';
  3564.   if ((c>='a') && (c<='f')) c-=('a'-'A');
  3565.   if ((c>='A') && (c<='F')) return (c-'A'+10);
  3566.   return 0;
  3567. }
  3568.  
  3569. static int ehex(char* s) {
  3570.   return 16*ehexh(*s)+ehexh(*(s+1));
  3571. }
  3572.  
  3573. // remplacer %20 par ' ', | par : etc..
  3574. // buffer MAX 1Ko
  3575. HTSEXT_API char* unescape_http(char* s) {
  3576.   char* tempo;
  3577.   int i,j=0;
  3578.   NOSTATIC_RESERVE(tempo, char, HTS_URLMAXSIZE*2);
  3579.   for (i=0;i<(int) strlen(s);i++) {
  3580.     if (s[i]=='%') {
  3581.       i++;
  3582.       tempo[j++]=(char) ehex(s+i);
  3583.       i++;    // sauter 2 caractΦres finalement
  3584.     }
  3585.     /*
  3586.     NON a cause de trucs comme /home/0,1837,1|7|1173|Content,00.html
  3587.     else if (s[i]=='|') {                     // exemple: file:///C|Program%20Files...
  3588.       tempo[j++]=':';
  3589.     }
  3590.     */
  3591.     else
  3592.       tempo[j++]=s[i];
  3593.   }
  3594.   tempo[j++]='\0';
  3595.   return tempo;
  3596. }
  3597.  
  3598. // unescape in URL/URI ONLY what has to be escaped, to form a standard URL/URI
  3599. HTSEXT_API char* unescape_http_unharm(char* s, int no_high) {
  3600.   char* tempo;
  3601.   int i,j=0;
  3602.   NOSTATIC_RESERVE(tempo, char, HTS_URLMAXSIZE*2);
  3603.   for (i=0;i<(int) strlen(s);i++) {
  3604.     if (s[i]=='%') {
  3605.       int nchar=(char) ehex(s+i+1);
  3606.  
  3607.       int test = (  CHAR_RESERVED(nchar)
  3608.                 || CHAR_DELIM(nchar)
  3609.                 || CHAR_UNWISE(nchar)
  3610.                 || CHAR_LOW(nchar)        /* CHAR_SPECIAL */
  3611.                 || CHAR_XXAVOID(nchar) 
  3612.                 || (
  3613.                   (no_high)
  3614.                   &&
  3615.                   CHAR_HIG(nchar)
  3616.                 )
  3617.                 );
  3618.  
  3619.       if (!test) {
  3620.         tempo[j++]=(char) ehex(s+i+1);
  3621.         i+=2;
  3622.       } else {
  3623.         tempo[j++]='%';
  3624.       }
  3625.     }
  3626.     /*
  3627.     NON a cause de trucs comme /home/0,1837,1|7|1173|Content,00.html
  3628.     else if (s[i]=='|') {                     // exemple: file:///C|Program%20Files...
  3629.       tempo[j++]=':';
  3630.     }
  3631.     */
  3632.     else
  3633.       tempo[j++]=s[i];
  3634.   }
  3635.   tempo[j++]='\0';
  3636.   return tempo;
  3637. }
  3638.  
  3639. // remplacer " par %xx etc..
  3640. // buffer MAX 1Ko
  3641. HTSEXT_API void escape_spc_url(char* s) {
  3642.   x_escape_http(s,2);
  3643. }
  3644. // smith / john -> smith%20%2f%20john
  3645. HTSEXT_API void escape_in_url(char* s) {
  3646.   x_escape_http(s,1);
  3647. }
  3648. // smith / john -> smith%20/%20john
  3649. HTSEXT_API void escape_uri(char* s) {
  3650.   x_escape_http(s,3);
  3651. }
  3652. HTSEXT_API void escape_uri_utf(char* s) {
  3653.   x_escape_http(s,30);
  3654. }
  3655. HTSEXT_API void escape_check_url(char* s) {
  3656.   x_escape_http(s,0);
  3657. }
  3658. // same as escape_check_url, but returns char*
  3659. HTSEXT_API char* escape_check_url_addr(char* s) {
  3660.   char* adr;
  3661.   escape_check_url(adr = concat(s,""));
  3662.   return adr;
  3663. }
  3664.  
  3665. // strip all control characters
  3666. HTSEXT_API void escape_remove_control(char* s) {
  3667.   unsigned char* ss = (unsigned char*) s;
  3668.   while(*ss) {
  3669.     if (*ss < 32) {    /* CONTROL characters go away! */
  3670.       char BIGSTK tmp[HTS_URLMAXSIZE*2];
  3671.       strcpybuff(tmp, ss+1);
  3672.       strcpybuff(ss, tmp);
  3673.     } else {
  3674.       ss++;
  3675.     }
  3676.   }
  3677. }
  3678.  
  3679. HTSEXT_API void x_escape_html(char* s) {
  3680.   while(*s) {
  3681.     int test=0;
  3682.       test = (
  3683.                 CHAR_HIG(*s)
  3684.              || CHAR_XXAVOID(*s) );
  3685.  
  3686.     if (test) {
  3687.       char BIGSTK buffer[HTS_URLMAXSIZE*3];
  3688.       int n;
  3689.       n = (int)(unsigned char) *s;
  3690.       strcpybuff(buffer, s+1);
  3691.       sprintf(s,"&#x%02x;", n);
  3692.       strcatbuff(s, buffer);
  3693.     }
  3694.     s++;
  3695.   }
  3696. }
  3697.  
  3698.  
  3699. HTSEXT_API void x_escape_http(char* s,int mode) {
  3700.   while(*s) {
  3701.     int test=0;
  3702.     if (mode == 0)
  3703.       test=(strchr("\" ",*s)!=0);
  3704.     else if (mode==1) {
  3705.       test = (  CHAR_RESERVED(*s)
  3706.              || CHAR_DELIM(*s)
  3707.              || CHAR_UNWISE(*s)
  3708.              || CHAR_SPECIAL(*s)
  3709.              || CHAR_XXAVOID(*s)
  3710.              || CHAR_MARK(*s));
  3711.     }
  3712.     else if (mode==2)
  3713.       test=(*s == ' ');           // n'escaper que espace
  3714.     else if (mode==3) {                   // Θchapper que ce qui est nΘcessaire
  3715.       test = (
  3716.                 CHAR_SPECIAL(*s)
  3717.              || CHAR_XXAVOID(*s) );
  3718.     }
  3719.     else if (mode==30) {                   // Θchapper que ce qui est nΘcessaire
  3720.       test = (
  3721.                 CHAR_LOW(*s)
  3722.              || CHAR_XXAVOID(*s) );
  3723.     }
  3724.  
  3725.     if (test) {
  3726.       char BIGSTK buffer[HTS_URLMAXSIZE*3];
  3727.       int n;
  3728.       n=(int)(unsigned char) *s;
  3729.       strcpybuff(buffer,s+1);
  3730.       sprintf(s,"%%%02x",n);
  3731.       strcatbuff(s,buffer);
  3732.     }
  3733.     s++;
  3734.   }
  3735. }
  3736.  
  3737. HTSEXT_API void escape_for_html_print(char* s, char* d) {
  3738.   for( ; *s ; s++) {
  3739.     if (*s == '&') {
  3740.       strcpybuff(d, "&");
  3741.       d += strlen(d);
  3742.     } else {
  3743.       *d++ = *s;
  3744.     }
  3745.   }
  3746.   *d = '\0';
  3747. }
  3748.  
  3749. HTSEXT_API void escape_for_html_print_full(char* s, char* d) {
  3750.   for( ; *s ; s++) {
  3751.     if (*s == '&') {
  3752.       strcpybuff(d, "&");
  3753.       d += strlen(d);
  3754.     } else if (CHAR_HIG(*s)) {
  3755.       sprintf(d, "&#x%02x;", (unsigned char) *s);
  3756.       d += strlen(d);
  3757.     } else {
  3758.       *d++ = *s;
  3759.     }
  3760.   }
  3761.   *d = '\0';
  3762. }
  3763.  
  3764.  
  3765.  
  3766. // concat, concatΦne deux chaines et renvoi le rΘsultat
  3767. // permet d'allΘger grandement le code
  3768. // il faut savoir qu'on ne peut mettre plus de 16 concat() dans une expression
  3769. typedef struct {
  3770.   char buff[16][HTS_URLMAXSIZE*2*2];
  3771.   int rol;
  3772. } concat_strc;
  3773. char* concat(const char* a,const char* b) {
  3774.   concat_strc* strc;
  3775.   NOSTATIC_RESERVE(strc, concat_strc, 1);
  3776.   strc->rol=((strc->rol+1)%16);    // roving pointer
  3777.   strcpybuff(strc->buff[strc->rol],a);
  3778.   if (b) strcatbuff(strc->buff[strc->rol],b);
  3779.   return strc->buff[strc->rol];
  3780. }
  3781. // conversion fichier / -> antislash
  3782. #if HTS_DOSNAME
  3783. char* __fconv(char* a) {
  3784.   int i;
  3785.   for(i=0;i<(int) strlen(a);i++)
  3786.     if (a[i]=='/')  // convertir
  3787.       a[i]='\\';
  3788.   return a;
  3789. }
  3790. char* fconcat(char* a,char* b) {
  3791.   return __fconv(concat(a,b));
  3792. }
  3793. char* fconv(char* a) {
  3794.   return __fconv(concat(a,""));
  3795. }
  3796. #endif
  3797.  
  3798. /* / et \\ en / */
  3799. char* __fslash(char* a) {
  3800.   int i;
  3801.   for(i=0;i<(int) strlen(a);i++)
  3802.     if (a[i]=='\\')  // convertir
  3803.       a[i]='/';
  3804.   return a;
  3805. }
  3806. char* fslash(char* a) {
  3807.   return __fslash(concat(a,""));
  3808. }
  3809.  
  3810. // conversion minuscules, avec buffer
  3811. char* convtolower(char* a) {
  3812.   concat_strc* strc;
  3813.   NOSTATIC_RESERVE(strc, concat_strc, 1);
  3814.   strc->rol=((strc->rol+1)%16);    // roving pointer
  3815.   strcpybuff(strc->buff[strc->rol],a);
  3816.   hts_lowcase(strc->buff[strc->rol]);  // lower case
  3817.   return strc->buff[strc->rol];
  3818. }
  3819.  
  3820. // conversion en minuscules
  3821. void hts_lowcase(char* s) {
  3822.   int i;
  3823.   for(i=0;i<(int) strlen(s);i++)
  3824.     if ((s[i]>='A') && (s[i]<='Z'))
  3825.       s[i]+=('a'-'A');
  3826. }
  3827.  
  3828. // remplacer un caractΦre d'une chaεne dans une autre
  3829. HTS_INLINE void hts_replace(char *s,char from,char to) { 
  3830.   char* a;
  3831.   while ((a=strchr(s,from))!=NULL) {
  3832.     *a=to;
  3833.   }
  3834. }
  3835.  
  3836.  
  3837. // caractΦre espace, guillemets, CR, LF etc..
  3838. /* SECTION OPTIMISEE:
  3839.   #define  is_space(c) (strchr(" \"\x0d\x0a\x09'",c)!=NULL)
  3840.   #define  is_realspace(c) (strchr(" \x0d\x0a\x09\x0c",c)!=NULL)
  3841. */
  3842. /*
  3843. HTS_INLINE int is_space(char c) {
  3844.   if (c==' ')  return 1;  // spc
  3845.   if (c=='"')  return 1;  // quote
  3846.   if (c==10)   return 1;  // lf
  3847.   if (c==13)   return 1;  // cr
  3848.   if (c=='\'') return 1;  // quote
  3849.   //if (c=='`')  return 1;  // backquote      << non
  3850.   if (c==9)    return 1;  // tab
  3851.   return 0;
  3852. }
  3853. */
  3854.  
  3855. // caractΦre espace, CR, LF, TAB
  3856. /*
  3857. HTS_INLINE int is_realspace(char c) {
  3858.   if (c==' ')  return 1;  // spc
  3859.   if (c==10)   return 1;  // lf
  3860.   if (c==13)   return 1;  // cr
  3861.   if (c==9)    return 1;  // tab
  3862.   return 0;
  3863. }
  3864. */
  3865.  
  3866.  
  3867.  
  3868.  
  3869.  
  3870. // deviner type d'un fichier local..
  3871. // ex: fil="toto.gif" -> s="image/gif"
  3872. void guess_httptype(char *s,const char *fil) {
  3873.   get_httptype(s,fil,1);
  3874. }
  3875. // idem
  3876. // flag: 1 si toujours renvoyer un type
  3877. void get_httptype(char *s,const char *fil,int flag) {
  3878.   if (ishtml(fil)==1)
  3879.     strcpybuff(s,"text/html");
  3880.   else {
  3881.     const char *a=fil+strlen(fil)-1;    
  3882.     while ( (*a!='.') && (*a!='/')  && (a>fil)) a--;
  3883.     if (*a=='.' && strlen(a) < 32) {
  3884.       int ok=0;
  3885.       int j=0;
  3886.       a++;
  3887.       while( (!ok) && (strnotempty(hts_mime[j][1])) ) {
  3888.         if (strfield2(hts_mime[j][1],a)) {
  3889.           if (hts_mime[j][0][0]!='*') {    // Une correspondance existe
  3890.             strcpybuff(s,hts_mime[j][0]);
  3891.             ok=1;
  3892.           }
  3893.         }
  3894.         j++;
  3895.       }
  3896.       
  3897.       if (!ok) if (flag) sprintf(s,"application/%s",a);
  3898.     } else {
  3899.       if (flag) strcpybuff(s,"application/octet-stream");
  3900.     }
  3901.   }
  3902. }
  3903.  
  3904. // get type of fil (php)
  3905. // s: buffer (text/html) or NULL
  3906. // return: 1 if known by user
  3907. int get_userhttptype(int setdefs,char *s,const char *ext) {
  3908.   char** buffer=NULL;
  3909.   NOSTATIC_RESERVE(buffer, char*, 1);
  3910.   if (setdefs) {
  3911.     *buffer=s;
  3912.     return 1;
  3913.   } else {
  3914.     if (s)
  3915.       s[0]='\0';
  3916.     if (!ext)
  3917.       return 0;
  3918.     if (*buffer) {
  3919.       char BIGSTK search[1024];
  3920.       char* detect;
  3921.       sprintf(search,"\n%s=",ext);    // php=text/html
  3922.       detect=strstr(*buffer,search);
  3923.       if (!detect) {
  3924.         sprintf(search,"\n%s\n",ext); // php\ncgi=text/html
  3925.         detect=strstr(*buffer,search);
  3926.       }
  3927.       if (detect) {
  3928.         detect=strchr(detect,'=');
  3929.         if (detect) {
  3930.           detect++;
  3931.           if (s) {
  3932.             char* a;
  3933.             a=strchr(detect,'\n');
  3934.             if (a) {
  3935.               strncatbuff(s,detect,(int) (a - detect));
  3936.             }
  3937.           }
  3938.           return 1;
  3939.         }
  3940.       }
  3941.     }
  3942.   }
  3943.   return 0;
  3944. }
  3945. // renvoyer extesion d'un type mime..
  3946. // ex: "image/gif" -> gif
  3947. void give_mimext(char *s,char *st) {   
  3948.   int ok=0;
  3949.   int j=0;
  3950.   s[0]='\0';
  3951.   while( (!ok) && (strnotempty(hts_mime[j][1])) ) {
  3952.     if (strfield2(hts_mime[j][0],st)) {
  3953.       if (hts_mime[j][1][0]!='*') {    // Une correspondance existe
  3954.         strcpybuff(s,hts_mime[j][1]);
  3955.         ok=1;
  3956.       }
  3957.     }
  3958.     j++;
  3959.   }
  3960.   // wrap "x" mimetypes, such as:
  3961.   // application/x-mp3
  3962.   // or
  3963.   // application/mp3
  3964.   if (!ok) {
  3965.     int p;
  3966.     char* a=NULL;
  3967.     if ((p=strfield(st,"application/x-")))
  3968.       a=st+p;
  3969.     else if ((p=strfield(st,"application/")))
  3970.       a=st+p;
  3971.     if (a) {
  3972.       if ((int)strlen(a) >= 1) {
  3973.         if ((int)strlen(a) <= 4) {
  3974.           strcpybuff(s,a);
  3975.           ok=1;
  3976.         }
  3977.       }
  3978.     }
  3979.   }
  3980. }
  3981. // extension connue?..
  3982. //  0 : non
  3983. //  1 : oui
  3984. //  2 : html
  3985. int is_knowntype(const char *fil) {
  3986.   int j=0;
  3987.   if (!fil)
  3988.     return 0;
  3989.   while(strnotempty(hts_mime[j][1])) {
  3990.     if (strfield2(hts_mime[j][1],fil)) {
  3991.       if (strfield2(hts_mime[j][0],"text/html"))
  3992.         return 2;
  3993.       else
  3994.         return 1;
  3995.     }
  3996.     j++;
  3997.   }
  3998.  
  3999.   // Known by user?
  4000.   return (is_userknowntype(fil));
  4001. }
  4002. // extension : html,gif..
  4003. char* get_ext(const char *fil) {
  4004.   char* fil_noquery;
  4005.   const char *a=fil+strlen(fil)-1;    
  4006.   NOSTATIC_RESERVE(fil_noquery, char, HTS_URLMAXSIZE*2);
  4007.  
  4008.   while ( (*a!='.') && (*a!='/')  && (a>fil)) a--;
  4009.   if (*a=='.') {
  4010.     char* b;
  4011.     fil_noquery[0]='\0';
  4012.     a++;  // pointer sur extension
  4013.     strncatbuff(fil_noquery,a,HTS_URLMAXSIZE);
  4014.     b=strchr(fil_noquery,'?');
  4015.     if (b)
  4016.       *b='\0';
  4017.     return concat(fil_noquery,"");
  4018.   }
  4019.   else
  4020.     return "";
  4021. }
  4022. // known type?..
  4023. //  0 : no
  4024. //  1 : yes
  4025. //  2 : html
  4026. // setdefs : set mime buffer:
  4027. //   file=(char*) "asp=text/html\nphp=text/html\n"
  4028. int is_userknowntype(const char *fil) {
  4029.   char BIGSTK mime[1024];
  4030.   if (!fil)
  4031.     return 0;
  4032.   if (!strnotempty(fil))
  4033.     return 0;
  4034.   mime[0]='\0';
  4035.   get_userhttptype(0,mime,fil);
  4036.   if (!strnotempty(mime))
  4037.     return 0;
  4038.   else if (strfield2(mime,"text/html"))
  4039.     return 2;
  4040.   else
  4041.     return 1;
  4042. }
  4043.  
  4044. // page dynamique?
  4045. // is_dyntype(get_ext("foo.asp"))
  4046. int is_dyntype(const char *fil) {
  4047.   int j=0;
  4048.   if (!fil)
  4049.     return 0;
  4050.   if (!strnotempty(fil))
  4051.     return 0;
  4052.   while(strnotempty(hts_ext_dynamic[j])) {
  4053.     if (strfield2(hts_ext_dynamic[j],fil)) {
  4054.       return 1;
  4055.     }
  4056.     j++;
  4057.   }
  4058.   return 0;
  4059. }
  4060.  
  4061. // types critiques qui ne doivent pas Ωtre changΘs car renvoyΘs par des serveurs qui ne
  4062. // connaissent pas le type
  4063. int may_unknown(const char* st) {
  4064.   int j=0;
  4065.   // types mΘdia
  4066.   if (may_be_hypertext_mime(st, "")) {
  4067.     return 1;
  4068.   }
  4069.   while(strnotempty(hts_mime_keep[j])) {
  4070.     if (strfield2(hts_mime_keep[j],st)) {      // trouvΘ
  4071.       return 1;
  4072.     }
  4073.     j++;
  4074.   }    
  4075.   return 0;
  4076. }
  4077.  
  4078.  
  4079. // -- Utils fichiers
  4080.  
  4081. // pretty print for i/o
  4082. void fprintfio(FILE* fp,char* buff,char* prefix) {
  4083.   char nl=1;
  4084.   while(*buff) {
  4085.     switch(*buff) {
  4086.     case 13: break;
  4087.     case 10:
  4088.       fprintf(fp,"\r\n");
  4089.       nl=1;
  4090.     break;
  4091.     default:
  4092.       if (nl)
  4093.         fprintf(fp,prefix);
  4094.       nl=0;
  4095.       fputc(*buff,fp);
  4096.     }
  4097.     buff++;
  4098.   }
  4099. }
  4100.  
  4101. /* Le fichier existe-t-il? (ou est-il accessible?) */
  4102. int fexist(char* s) {
  4103.   struct stat st;
  4104.   memset(&st, 0, sizeof(st));
  4105.   if (stat(s, &st) == 0) {
  4106.     if (S_ISREG(st.st_mode)) {
  4107.       return 1;
  4108.     }
  4109.   }
  4110.   return 0;
  4111. } 
  4112.  
  4113. /* Taille d'un fichier, -1 si n'existe pas */
  4114. /* fp->_cnt ne fonctionne pas sur toute les plate-formes :-(( */
  4115. /* Note: NOT YET READY FOR 64-bit */
  4116. INTsys fsize(char* s) {
  4117.   FILE* fp;
  4118.   if (strnotempty(s)==0)     // nom vide: erreur
  4119.     return -1;
  4120.   fp=fopen(fconv(s),"rb");
  4121.   if (fp!=NULL) {
  4122.     INTsys i;
  4123.     fseek(fp,0,SEEK_END);
  4124. #ifdef HTS_FSEEKO
  4125.     i=ftello(fp);
  4126. #else
  4127.     i=ftell(fp);
  4128. #endif
  4129.     fclose(fp);
  4130.     return i;
  4131.   } else return -1;
  4132. }
  4133.  
  4134. INTsys fpsize(FILE* fp) {
  4135.   INTsys oldpos,size;
  4136.   if (!fp)
  4137.     return -1;
  4138. #ifdef HTS_FSEEKO
  4139.   oldpos=ftello(fp);
  4140. #else
  4141.   oldpos=ftell(fp);
  4142. #endif
  4143.   fseek(fp,0,SEEK_END);
  4144. #ifdef HTS_FSEEKO
  4145.   size=ftello(fp);
  4146.   fseeko(fp,oldpos,SEEK_SET);
  4147. #else
  4148.   size=ftell(fp);
  4149.   fseek(fp,oldpos,SEEK_SET);
  4150. #endif
  4151.   return size;
  4152. }
  4153.  
  4154. /* root dir, with ending / */
  4155. typedef struct {
  4156.   char path[1024+4];
  4157.   int init;
  4158. } hts_rootdir_strc;
  4159. HTSEXT_API char* hts_rootdir(char* file) {
  4160.   static hts_rootdir_strc strc = {"", 0};
  4161.   //NOSTATIC_RESERVE(strc, hts_rootdir_strc, 1);
  4162.   if (file) {
  4163.     if (!strc.init) {
  4164.       strc.path[0]='\0';
  4165.       strc.init=1;
  4166.       if (strnotempty(file)) {
  4167.         char* a;
  4168.         strcpybuff(strc.path,file);
  4169.         while((a=strrchr(strc.path,'\\'))) *a='/';
  4170.         if ((a=strrchr(strc.path,'/'))) {
  4171.           *(a+1)='\0';
  4172.         } else
  4173.           strc.path[0]='\0';
  4174.       }
  4175.       if (!strnotempty(strc.path)) {
  4176.         if( getcwd( strc.path, 1024 ) == NULL )
  4177.             strc.path[0]='\0';
  4178.         else
  4179.           strcatbuff(strc.path,"/");
  4180.       }
  4181.     }
  4182.     return NULL;
  4183.   } else if (strc.init)
  4184.     return strc.path;
  4185.   else
  4186.     return "";
  4187. }
  4188.  
  4189.  
  4190.  
  4191. HTSEXT_API hts_stat_struct HTS_STAT;
  4192. //
  4193. // return  number of downloadable bytes, depending on rate limiter
  4194. // see engine_stats() routine, too
  4195. // this routine works quite well for big files and regular ones, but apparently the rate limiter has
  4196. // some problems with very small files (rate too high)
  4197. LLint check_downloadable_bytes(int rate) {
  4198.   if (rate>0) {
  4199.     TStamp time_now;
  4200.     TStamp elapsed_useconds;
  4201.     LLint bytes_transfered_during_period;
  4202.     LLint left;
  4203.  
  4204.     // get the older timer
  4205.     int id_timer = (HTS_STAT.istat_idlasttimer + 1) % 2;
  4206.  
  4207.     time_now=mtime_local();
  4208.     elapsed_useconds = time_now - HTS_STAT.istat_timestart[id_timer];
  4209.     // NO totally stupid - elapsed_useconds+=1000;      // for the next second, too
  4210.     bytes_transfered_during_period = (HTS_STAT.HTS_TOTAL_RECV-HTS_STAT.istat_bytes[id_timer]);
  4211.     
  4212.     left = ((rate * elapsed_useconds)/1000) - bytes_transfered_during_period;
  4213.     if (left <= 0)
  4214.       left = 0;
  4215.     
  4216.     return left;
  4217.   } else
  4218.     return TAILLE_BUFFER;
  4219. }
  4220.  
  4221. //
  4222. // 0 : OK
  4223. // 1 : slow down
  4224. #if 0
  4225. int HTS_TOTAL_RECV_CHECK(int var) {
  4226.   if (HTS_STAT.HTS_TOTAL_RECV_STATE)
  4227.     return 1;
  4228.     /*
  4229.     {
  4230.     if (HTS_STAT.HTS_TOTAL_RECV_STATE==3) { 
  4231.       var = min(var,32); 
  4232.       Sleep(250); 
  4233.     } else if (HTS_STAT.HTS_TOTAL_RECV_STATE==2) { 
  4234.       var = min(var,256); 
  4235.       Sleep(100); 
  4236.     } else { 
  4237.       var/=2; 
  4238.       if (var<=0) var=1; 
  4239.       Sleep(50); 
  4240.     } 
  4241.   }
  4242.     */
  4243.   return 0;
  4244. }
  4245. #endif
  4246.  
  4247. // Lecture dans buff de size octets au maximum en utilisant la socket r (structure htsblk)
  4248. // returns: 
  4249. // >0 : data received
  4250. // == 0 : not yet data
  4251. // <0: error or no data: READ_ERROR, READ_EOF or READ_TIMEOUT
  4252. HTS_INLINE int hts_read(htsblk* r,char* buff,int size) {
  4253.   int retour;
  4254.   //  return read(soc,buff,size);
  4255.   if (r->is_file) {
  4256. #if HTS_WIDE_DEBUG    
  4257.     DEBUG_W("read(%p, %d, %d)\n" _ (void*) buff _ (int) size _ (int) r->fp);
  4258. #endif
  4259.     if (r->fp)
  4260.       retour = (int)fread(buff,1,size,r->fp);
  4261.     else
  4262.       retour = READ_ERROR;
  4263.   } else {
  4264. #if HTS_WIDE_DEBUG    
  4265.     DEBUG_W("recv(%d, %p, %d)\n" _ (int) r->soc _ (void*) buff _ (int) size);
  4266.     if (r->soc==INVALID_SOCKET)
  4267.       printf("!!WIDE_DEBUG ERROR, soc==INVALID hts_read\n");
  4268. #endif
  4269.     //HTS_TOTAL_RECV_CHECK(size);         // Diminuer au besoin si trop de donnΘes reτues
  4270. #if HTS_USEOPENSSL
  4271.     if (SSL_is_available && r->ssl) {
  4272.       retour = SSL_read(r->ssl_con, buff, size);
  4273.       if (retour <= 0) {
  4274.         int err_code = SSL_get_error(r->ssl_con, retour);
  4275.         if (
  4276.           (err_code == SSL_ERROR_WANT_READ)
  4277.           ||
  4278.           (err_code == SSL_ERROR_WANT_WRITE)
  4279.           ) 
  4280.         {
  4281.           retour = 0;             /* no data yet (ssl cache) */
  4282.         } else if (err_code == SSL_ERROR_ZERO_RETURN) {
  4283.           retour = READ_EOF;             /* completed */
  4284.         } else {
  4285.           retour = READ_ERROR;            /* eof or error */
  4286.         }
  4287.       }
  4288.     } else {
  4289. #endif
  4290.     retour=recv(r->soc,buff,size,0);
  4291.     if (retour == 0) {
  4292.       retour = READ_EOF;
  4293.     } else if (retour < 0) {
  4294.       retour = READ_ERROR;
  4295.     }
  4296.   }
  4297.   if (retour > 0)    // compter flux entrant
  4298.     HTS_STAT.HTS_TOTAL_RECV+=retour;
  4299. #if HTS_USEOPENSSL
  4300.   }
  4301. #endif
  4302. #if HTS_WIDE_DEBUG    
  4303.   DEBUG_W("recv/read done (%d bytes)\n" _ (int) retour);
  4304. #endif
  4305.   return retour;
  4306. }
  4307.  
  4308.  
  4309. // -- Gestion cache DNS --
  4310. // 'RX98
  4311. #if HTS_DNSCACHE
  4312.  
  4313. // 'capsule' contenant uniquement le cache
  4314. t_dnscache* _hts_cache(void) {
  4315.   t_dnscache* cache;
  4316.   NOSTATIC_RESERVE(cache, t_dnscache, 1);
  4317.   return cache;
  4318. }
  4319. // free the cache
  4320. static void hts_cache_free_(t_dnscache* cache) {
  4321.   if (cache != NULL) {
  4322.     if (cache->n != NULL) {
  4323.       hts_cache_free_(cache->n);
  4324.     }
  4325.     freet(cache);
  4326.   }
  4327. }
  4328. void hts_cache_free(t_dnscache* cache) {
  4329.   if (cache != NULL && cache->n != NULL) {
  4330.     hts_cache_free_(cache->n);
  4331.     cache->n = NULL;
  4332.   }
  4333. }
  4334.  
  4335. // lock le cache dns pour tout opΘration d'ajout
  4336. // plus prudent quand plusieurs threads peuvent Θcrire dedans..
  4337. // -1: status? 0: libΘrer 1:locker
  4338.  
  4339. /* 
  4340.   Simple lock function for cache
  4341.  
  4342.   Return value: always 0
  4343.   Parameter:
  4344.   1 wait for lock (mutex) available and lock it
  4345.   0 unlock the mutex
  4346.   [-1 check if locked (always return 0 with mutex)]
  4347.   -999 initialize
  4348. */
  4349. #if USE_BEGINTHREAD
  4350. int _hts_lockdns(int i) {
  4351.   static PTHREAD_LOCK_TYPE hMutex; 
  4352.   return htsSetLock(&hMutex,i);
  4353. }
  4354. #else
  4355. int _hts_lockdns(int i) {
  4356.   int l=0;
  4357.   if (i>=0)
  4358.     l=i;
  4359.   return l;
  4360. }
  4361. #endif
  4362.  
  4363. // routine pour le cache - retour optionnel α donner α chaque fois
  4364. // NULL: nom non encore testΘ dans le cache
  4365. // si h_length==0 alors le nom n'existe pas dans le dns
  4366. t_hostent* _hts_ghbn(t_dnscache* cache,char* iadr,t_hostent* retour) {
  4367.   // attendre que le cache dns soit prΩt
  4368.   //while(_hts_lockdns(-1));  // attendre libΘration
  4369.   _hts_lockdns(1);          // locker
  4370.  
  4371.   while(1) {
  4372.     if (strcmp(cache->iadr,iadr)==0) {  // ok trouvΘ
  4373.       if (cache->host_length>0) {  // entrΘe valide
  4374.         if (retour->h_addr_list[0])
  4375.           memcpy(retour->h_addr_list[0], cache->host_addr, cache->host_length);
  4376.         retour->h_length=cache->host_length;
  4377.       } else if (cache->host_length==0) {  // en cours
  4378.         _hts_lockdns(0);          // dΘlocker
  4379.         return NULL;
  4380.       } else {                    // erreur dans le dns, dΘja vΘrifiΘ
  4381.         if (retour->h_addr_list[0])
  4382.           retour->h_addr_list[0][0]='\0';
  4383.         retour->h_length=0;  // erreur, n'existe pas
  4384.       }
  4385.       _hts_lockdns(0);          // dΘlocker
  4386.       return retour;
  4387.     } else {    // on a pas encore trouvΘ
  4388.       if (cache->n!=NULL) { // chercher encore
  4389.         cache=cache->n;   // suivant!
  4390.       } else {
  4391.         _hts_lockdns(0);          // dΘlocker
  4392.         return NULL;    // non prΘsent        
  4393.       }
  4394.     }    
  4395.   }
  4396. }
  4397.  
  4398. // tester si iadr a dΘja ΘtΘ testΘ (ou en cours de test)
  4399. // 0 non encore
  4400. // 1 ok
  4401. // 2 non prΘsent
  4402. int hts_dnstest(char* _iadr) {
  4403.   char* iadr;
  4404.   t_dnscache* cache=_hts_cache();  // adresse du cache 
  4405.   NOSTATIC_RESERVE(iadr, char, HTS_URLMAXSIZE*2);
  4406.  
  4407.   // sauter user:pass@ Θventuel
  4408.   strcpybuff(iadr,jump_identification(_iadr));
  4409.   // couper Θventuel :
  4410.   {
  4411.     char *a;
  4412.     if ( (a=jump_toport(iadr)) )
  4413.       *a='\0';
  4414.   }
  4415.  
  4416. #if HTS_WIN
  4417.   if (inet_addr(iadr)!=INADDR_NONE)  // numΘrique
  4418. #else
  4419.   if (inet_addr(iadr)!=(in_addr_t) -1 )  // numΘrique
  4420. #endif
  4421.     return 1;
  4422.  
  4423.   // while(_hts_lockdns(-1));  // attendre libΘration
  4424.   _hts_lockdns(1);          // locker
  4425.   while(1) {
  4426.     if (strcmp(cache->iadr,iadr)==0) {  // ok trouvΘ
  4427.       _hts_lockdns(0);          // dΘlocker
  4428.       return 1;    // prΘsent!
  4429.     } else {    // on a pas encore trouvΘ
  4430.       if (cache->n!=NULL) { // chercher encore
  4431.         cache=cache->n;   // suivant!
  4432.       } else {
  4433.         _hts_lockdns(0);          // dΘlocker
  4434.         return 2;    // non prΘsent        
  4435.       }
  4436.     }    
  4437.   }
  4438. }
  4439.  
  4440.  
  4441. HTSEXT_API t_hostent* vxgethostbyname(char* hostname, void* v_buffer) {
  4442.   t_fullhostent* buffer = (t_fullhostent*) v_buffer;
  4443.   /* Clear */
  4444.   fullhostent_init(buffer);
  4445.  
  4446.   /* Protection */
  4447.   if (!strnotempty(hostname)) {
  4448.     return NULL;
  4449.   }
  4450.  
  4451.   /* 
  4452.     Strip [] if any : [3ffe:b80:1234:1::1] 
  4453.     The resolver doesn't seem to handle IP6 addresses in brackets
  4454.   */
  4455.   if ((hostname[0] == '[') && (hostname[strlen(hostname)-1] == ']')) {
  4456.     char BIGSTK tempo[HTS_URLMAXSIZE*2];
  4457.     tempo[0]='\0';
  4458.     strncatbuff(tempo, hostname+1, strlen(hostname)-2);
  4459.     strcpybuff(hostname, tempo);
  4460.   }
  4461.  
  4462.   {
  4463. #if HTS_INET6==0
  4464.   /*
  4465.   ipV4 resolver
  4466.     */
  4467.     t_hostent* hp=gethostbyname(hostname);
  4468.     if (hp!=NULL) {
  4469.       if ( (hp->h_length) && ( ((unsigned int) hp->h_length) <= buffer->addr_maxlen) ) {
  4470.         memcpy(buffer->hp.h_addr_list[0], hp->h_addr_list[0], hp->h_length);
  4471.         buffer->hp.h_length = hp->h_length;
  4472.         return &(buffer->hp);
  4473.       }
  4474.     }
  4475. #else
  4476.     /*
  4477.     ipV6 resolver
  4478.     */
  4479.     /*
  4480.     int error_num=0;
  4481.     t_hostent* hp=getipnodebyname(hostname, AF_INET6, AI_DEFAULT, &error_num);
  4482.     oops, deprecated :(
  4483.     */
  4484.     struct addrinfo* res = NULL;
  4485.     struct addrinfo hints;
  4486.     memset(&hints, 0, sizeof(hints));
  4487.     if (IPV6_resolver == 1)        // V4 only (for bogus V6 entries)
  4488.       hints.ai_family = PF_INET;
  4489.     else if (IPV6_resolver == 2)   // V6 only (for testing V6 only)
  4490.       hints.ai_family = PF_INET6;
  4491.     else                           // V4 + V6
  4492.       hints.ai_family = PF_UNSPEC;
  4493.     hints.ai_socktype = SOCK_STREAM;
  4494.     hints.ai_protocol = IPPROTO_TCP;
  4495.     if (getaddrinfo(hostname, NULL, &hints, &res) == 0) {
  4496.       if (res) {
  4497.         if ( (res->ai_addr) && (res->ai_addrlen) && (res->ai_addrlen <= buffer->addr_maxlen) ) {
  4498.           memcpy(buffer->hp.h_addr_list[0], res->ai_addr, res->ai_addrlen);
  4499.           buffer->hp.h_length = res->ai_addrlen;
  4500.           freeaddrinfo(res);
  4501.           return &(buffer->hp);
  4502.         }
  4503.       }
  4504.     }
  4505.     if (res) {
  4506.       freeaddrinfo(res);
  4507.     }
  4508.     
  4509. #endif
  4510.   }
  4511.   return NULL;
  4512. }
  4513.  
  4514. // cache dns interne α HTS // ** FREE A FAIRE sur la chaine
  4515. t_hostent* hts_gethostbyname(char* _iadr, void* v_buffer) {
  4516.   char BIGSTK iadr[HTS_URLMAXSIZE*2];
  4517.   t_fullhostent* buffer = (t_fullhostent*) v_buffer;
  4518.   t_dnscache* cache=_hts_cache();  // adresse du cache
  4519.   t_hostent* hp;
  4520.  
  4521.   /* Clear */
  4522.   fullhostent_init(buffer);
  4523.  
  4524.   strcpybuff(iadr,jump_identification(_iadr));
  4525.   // couper Θventuel :
  4526.   {
  4527.     char *a;
  4528.     if ( (a=jump_toport(iadr)) )
  4529.       *a='\0';
  4530.   }
  4531.  
  4532.   // effacer structure de retour, crΘer nouvelle
  4533.   /*
  4534.   memset(&host, 0, sizeof(t_hostent));  
  4535.   host.h_addr_list=he;
  4536.   he[0]=NULL;
  4537.   he[1]=NULL;  
  4538.   host.h_length=0;  
  4539.   */
  4540.   cache->iadr[0]='*';
  4541.   cache->iadr[1]='\0';
  4542.   
  4543.   /* get IP from the dns cache */
  4544.   hp = _hts_ghbn(cache, iadr, &buffer->hp);
  4545.   if (hp) {
  4546.     if (hp->h_length>0)
  4547.       return hp;
  4548.     else
  4549.       return NULL;    // entrΘe erronΘe (erreur DNS) dans le DNS
  4550.   } else {  // non prΘsent dans le cache dns, tester
  4551.     t_dnscache* c=cache;
  4552.     while(c->n) c=c->n;    // calculer queue
  4553.     
  4554. #if HTS_WIDE_DEBUG    
  4555.     DEBUG_W("gethostbyname\n");
  4556. #endif      
  4557. #if HDEBUG
  4558.     printf("gethostbyname (not in cache)\n");
  4559. #endif
  4560.     {
  4561.       unsigned long inetaddr;
  4562. #if HTS_WIN
  4563.       if ((inetaddr=inet_addr(iadr))==INADDR_NONE) {
  4564. #else
  4565.       if ((inetaddr=inet_addr(iadr))==(in_addr_t) -1 ) {
  4566. #endif        
  4567. #if DEBUGDNS 
  4568.         printf("resolving (not cached) %s\n",iadr);
  4569. #endif
  4570.         hp=vxgethostbyname(iadr, buffer);  // calculer IP host
  4571.       } else {     // numΘrique, convertir sans passer par le dns
  4572.         buffer->hp.h_addr_list[0]=(char*) &inetaddr;
  4573.         buffer->hp.h_length=4;
  4574.         hp=&buffer->hp;
  4575.       }
  4576.     }
  4577. #if HTS_WIDE_DEBUG    
  4578.     DEBUG_W("gethostbyname done\n");
  4579. #endif
  4580.     cache->n=(t_dnscache*) calloct(1,sizeof(t_dnscache));
  4581.     if (cache->n!=NULL) {
  4582.       strcpybuff(cache->n->iadr,iadr);
  4583.       if (hp!=NULL) {
  4584.         memcpy(cache->n->host_addr, hp->h_addr_list[0], hp->h_length);
  4585.         cache->n->host_length=hp->h_length;
  4586.       } else {
  4587.         cache->n->host_addr[0]='\0';
  4588.         cache->n->host_length=0;  // non existant dans le dns
  4589.       }
  4590.       cache->n->n=NULL;
  4591.       return hp;
  4592.     } else {  // on peut pas noter, mais on peut renvoyer le rΘsultat
  4593.       return hp;
  4594.     }        
  4595.   }  // retour hp du cache
  4596. }
  4597.  
  4598. #else
  4599. HTS_INLINE t_hostent* hts_gethostbyname(char* iadr, t_fullhostent* buffer) {
  4600.   t_hostent* retour;
  4601. #if HTS_WIDE_DEBUG    
  4602.   DEBUG_W("gethostbyname (2)\n");
  4603. #endif
  4604. #if DEBUGDNS 
  4605.     printf("blocking method gethostbyname() in progress for %s\n",iadr);
  4606. #endif
  4607.   retour=vxgethostbyname(jump_identification(iadr), );
  4608. #if HTS_WIDE_DEBUG    
  4609.   DEBUG_W("gethostbyname (2) done\n");
  4610. #endif
  4611.   return retour;
  4612. }
  4613. #endif
  4614.  
  4615.  
  4616. // --- Tracage des mallocs() ---
  4617. #ifdef HTS_TRACE_MALLOC
  4618. //#define htsLocker(A, N) htsLocker(A, N)
  4619. #define htsLocker(A, N) do {} while(0)
  4620. static mlink trmalloc = {NULL,0,0,NULL};
  4621. static int trmalloc_id=0;
  4622. static PTHREAD_LOCK_TYPE* mallocMutex = NULL;
  4623. static void hts_meminit(void) {
  4624.   //if (mallocMutex == NULL) {
  4625.   //  mallocMutex = calloc(sizeof(*mallocMutex), 1);
  4626.   //  htsLocker(mallocMutex, -999);
  4627.   //}
  4628. }
  4629. void* hts_malloc(size_t len) {
  4630.   void* adr;
  4631.   hts_meminit();
  4632.   htsLocker(mallocMutex, 1);
  4633.   fassert(len > 0);
  4634.   adr = hts_xmalloc(len, 0);
  4635.   htsLocker(mallocMutex, 0);
  4636.   return adr;
  4637. }
  4638. void* hts_calloc(size_t len,size_t len2) {
  4639.   void* adr;
  4640.   hts_meminit();
  4641.   fassert(len > 0);
  4642.   fassert(len2 > 0);
  4643.   htsLocker(mallocMutex, 1);
  4644.   adr = hts_xmalloc(len, len2);
  4645.   htsLocker(mallocMutex, 0);
  4646.   memset(adr, 0, len * len2);
  4647.   return adr;
  4648. }
  4649. void* hts_strdup(char* str) {
  4650.   size_t size = str ? strlen(str) : 0;
  4651.   char* adr = (char*) hts_malloc(size + 1);
  4652.   fassert(adr != NULL);
  4653.   strcpy(adr, str ? str : "");
  4654.   return adr;
  4655. }
  4656. void* hts_xmalloc(size_t len,size_t len2) {
  4657.   mlink* lnk = (mlink*) calloc(1,sizeof(mlink));
  4658.   fassert(lnk != NULL);
  4659.   fassert(len > 0);
  4660.   fassert(len2 >= 0);
  4661.   if (lnk) {
  4662.     void*  r   = NULL;
  4663.     int size, bsize = sizeof(t_htsboundary);
  4664.     if (len2)
  4665.       size = len * len2;
  4666.     else
  4667.       size = len;
  4668.     size += ((bsize - (size % bsize)) % bsize);  /* check alignement */
  4669.     r = malloc(size + bsize*2);
  4670.     fassert(r != NULL);
  4671.     if (r) {
  4672.       * ( (t_htsboundary*) ((char*) r ) ) 
  4673.         = * ( (t_htsboundary*) ( (char*) r + size + bsize ) )
  4674.         = htsboundary;
  4675.       ((char*) r) += bsize;    /* boundary */
  4676.       lnk->adr = r;
  4677.       lnk->len = size;
  4678.       lnk->id = trmalloc_id++;
  4679.       lnk->next = trmalloc.next;
  4680.       trmalloc.next = lnk;
  4681.       return r;
  4682.     } else {
  4683.       free(lnk);
  4684.     }
  4685.   }
  4686.   return NULL;
  4687. }
  4688. void hts_free(void* adr) {
  4689.   mlink* lnk = &trmalloc;
  4690.   int bsize = sizeof(t_htsboundary);
  4691.   fassert(adr != NULL);
  4692.   if (!adr) {
  4693.     return;
  4694.   }
  4695.   htsLocker(mallocMutex, 1);
  4696.   while(lnk->next != NULL) {
  4697.     if (lnk->next->adr == adr) {
  4698.       mlink* blk_free=lnk->next;
  4699.       fassert(blk_free->id != -1);
  4700.       fassert( * ( (t_htsboundary*) ( (char*) adr - bsize ) ) == htsboundary );
  4701.       fassert( * ( (t_htsboundary*) ( (char*) adr + blk_free->len ) ) == htsboundary );
  4702.       lnk->next=lnk->next->next;
  4703.       free((void*) blk_free);
  4704.       //blk_free->id=-1;
  4705.       free((char*) adr - bsize);
  4706.       htsLocker(mallocMutex, 0);
  4707.       return;
  4708.     }
  4709.     lnk = lnk->next;
  4710.     fassert(lnk->next != NULL);
  4711.   }
  4712.   free(adr);
  4713.   htsLocker(mallocMutex, 0);
  4714. }
  4715. void* hts_realloc(void* adr,size_t len) {
  4716.   int bsize = sizeof(t_htsboundary);
  4717.   len += ((bsize - (len % bsize)) % bsize);  /* check alignement */
  4718.   if (adr != NULL) {
  4719.     mlink* lnk = &trmalloc;
  4720.     htsLocker(mallocMutex, 1);
  4721.     while(lnk->next != NULL)  {
  4722.       if (lnk->next->adr==adr) {
  4723.         {
  4724.           mlink* blk_free=lnk->next;
  4725.           fassert(blk_free->id != -1);
  4726.           fassert( * ( (t_htsboundary*) ( (char*) adr - bsize ) ) == htsboundary );
  4727.           fassert( * ( (t_htsboundary*) ( (char*) adr + blk_free->len ) ) == htsboundary );
  4728.         }
  4729.         adr = realloc((char*) adr - bsize, len + bsize * 2);
  4730.         fassert(adr != NULL);
  4731.         lnk->next->adr = (char*) adr + bsize;
  4732.         lnk->next->len = len;
  4733.         * ( (t_htsboundary*) ( (char*) adr ) ) 
  4734.           = * ( (t_htsboundary*) ( (char*) adr + len + bsize) ) 
  4735.           = htsboundary;
  4736.         htsLocker(mallocMutex, 0);
  4737.         return (char*) adr + bsize;
  4738.       }
  4739.       lnk = lnk->next;
  4740.       fassert(lnk->next != NULL);
  4741.     }
  4742.     htsLocker(mallocMutex, 0);
  4743.   }
  4744.   return hts_malloc(len);
  4745. }
  4746. mlink* hts_find(char* adr) {
  4747.   char* stkframe = (char*) &stkframe;
  4748.   mlink* lnk = &trmalloc;
  4749.   int bsize = sizeof(t_htsboundary);
  4750.   fassert(adr != NULL);
  4751.   if (!adr) {
  4752.     return NULL;
  4753.   }
  4754.   htsLocker(mallocMutex, 1);
  4755.   while(lnk->next != NULL) {
  4756.     if (adr >= lnk->next->adr && adr <= lnk->next->adr + lnk->next->len) {   /* found */
  4757.       htsLocker(mallocMutex, 0);
  4758.       return lnk->next;
  4759.     }
  4760.     lnk = lnk->next;
  4761.   }
  4762.   htsLocker(mallocMutex, 0);
  4763.   {
  4764.     int depl = (int) (adr - stkframe);
  4765.     if (depl < 0) depl = -depl;
  4766.     //fassert(depl < 512000);   /* near the stack frame.. doesn't look like malloc but stack variable */
  4767.     return NULL;
  4768.   }
  4769. }
  4770. // check the malloct() and calloct() trace stack
  4771. void  hts_freeall(void) {
  4772.   int bsize = sizeof(t_htsboundary);
  4773.   while(trmalloc.next) {
  4774. #if MEMDEBUG
  4775.     printf("* block %d\t not released: at %d\t (%d\t bytes)\n",trmalloc.next->id,trmalloc.next->adr,trmalloc.next->len);
  4776. #endif
  4777.     if (trmalloc.next->id != -1) {
  4778.       free((char*) trmalloc.next->adr - bsize);
  4779.     }
  4780.   }
  4781. }
  4782. #endif
  4783.  
  4784.  
  4785. // -- divers //
  4786.  
  4787. // cut path and project name
  4788. // patch also initial path
  4789. void cut_path(char* fullpath,char* path,char* pname) {
  4790.   path[0]=pname[0]='\0';
  4791.   if (strnotempty(fullpath)) {
  4792.     if ((fullpath[strlen(fullpath)-1]=='/') || (fullpath[strlen(fullpath)-1]=='\\'))
  4793.       fullpath[strlen(fullpath)-1]='\0';
  4794.     if (strlen(fullpath)>1) {
  4795.       char* a;
  4796.       while( (a=strchr(fullpath,'\\')) ) *a='/';     // remplacer par /
  4797.       a=fullpath+strlen(fullpath)-2;
  4798.       while( (*a!='/') && ( a > fullpath)) a--;
  4799.       if (*a=='/') a++;
  4800.       strcpybuff(pname,a);
  4801.       strncatbuff(path,fullpath,(int) (a - fullpath));
  4802.     }
  4803.   }
  4804. }
  4805.  
  4806.  
  4807.  
  4808. // -- Gestion protocole ftp --
  4809.  
  4810. #if HTS_WIN
  4811. int ftp_available(void) {
  4812.   return 1;
  4813. }
  4814. #else
  4815. int ftp_available(void) {
  4816.   return 1;   // ok!
  4817.   //return 0;   // SOUS UNIX, PROBLEMES
  4818. }
  4819. #endif
  4820.  
  4821.  
  4822. int hts_dgb_init = 0;
  4823. FILE* hts_dgb_init_fp = NULL;
  4824. static void hts_dgb(char* msg);
  4825. HTSEXT_API void hts_debug(int level) {
  4826.   hts_dgb_init = level;
  4827.   if (hts_dgb_init > 0) {
  4828.     hts_dgb("hts_debug() called");
  4829.   }
  4830. }
  4831. static void hts_dgb(char* msg) {
  4832.   if (hts_dgb_init > 0) {
  4833.     if (hts_dgb_init_fp == NULL) {
  4834. #ifdef _WIN32_WCE
  4835.       hts_dgb_init_fp = fopen("\\Temp\\hts-debug.txt", "wb");
  4836. #else
  4837.       hts_dgb_init_fp = fopen("hts-debug.txt", "wb");
  4838. #endif
  4839.       if (hts_dgb_init_fp != NULL) {
  4840.         fprintf(hts_dgb_init_fp, "* Creating file\r\n");
  4841.       }
  4842.     }
  4843.     if (hts_dgb_init_fp != NULL) {
  4844.       fprintf(hts_dgb_init_fp, "%s\r\n", msg);
  4845.       fflush(hts_dgb_init_fp);
  4846.     }
  4847.   }
  4848. }
  4849.  
  4850. HTSEXT_API int hts_init(void) {
  4851.   static int hts_init_ok = 0;
  4852.  
  4853.   hts_dgb("entering hts_init()");    /* debug */
  4854.  
  4855. #ifdef _WIN32_WCE
  4856. #ifndef HTS_CECOMPAT
  4857.   xceinit(L"");
  4858. #endif
  4859. #endif
  4860.  
  4861.   /* Init threads */
  4862.   if (!hts_init_ok) {
  4863.     htsthread_init();
  4864.   }
  4865.  
  4866.   /* Ensure external modules are loaded */
  4867.   hts_dgb("calling htspe_init()");    /* debug */
  4868.   htspe_init();
  4869.  
  4870.   /* MD5 Auto-test */
  4871.   {
  4872.     char digest[32 + 2];
  4873.     unsigned char* atest = (unsigned char*)"MD5 Checksum Autotest";
  4874.     digest[0] = '\0';
  4875.     domd5mem(atest, strlen(atest), digest, 1); /* a42ec44369da07ace5ec1d660ba4a69a */
  4876.     if (strcmp(digest, "a42ec44369da07ace5ec1d660ba4a69a") != 0) {
  4877.       int fatal_broken_md5 = 0;
  4878.       assertf(fatal_broken_md5);
  4879.     }
  4880.   }
  4881.  
  4882.   hts_dgb("initializing default wrappers");    /* debug */
  4883.   if (!hts_init_ok) {
  4884.     hts_init_ok = 1;
  4885.     // default wrappers
  4886.     htswrap_init();
  4887.     htswrap_add("init",htsdefault_init);
  4888.     htswrap_add("free",htsdefault_uninit);
  4889.     htswrap_add("start",htsdefault_start);
  4890.     htswrap_add("change-options",htsdefault_chopt);
  4891.     htswrap_add("end",htsdefault_end);
  4892.     htswrap_add("preprocess-html",htsdefault_preprocesshtml);
  4893.     htswrap_add("postprocess-html",htsdefault_postprocesshtml);
  4894.     htswrap_add("check-html",htsdefault_checkhtml);
  4895.     htswrap_add("loop",htsdefault_loop);
  4896.     htswrap_add("query",htsdefault_query);
  4897.     htswrap_add("query2",htsdefault_query2);
  4898.     htswrap_add("query3",htsdefault_query3);
  4899.     htswrap_add("check-link",htsdefault_check);
  4900.     htswrap_add("pause",htsdefault_pause);
  4901.     htswrap_add("save-file",htsdefault_filesave);
  4902.     htswrap_add("link-detected",htsdefault_linkdetected);
  4903.     htswrap_add("link-detected2",htsdefault_linkdetected2);
  4904.     htswrap_add("transfer-status",htsdefault_xfrstatus);
  4905.     htswrap_add("save-name",htsdefault_savename);
  4906.     htswrap_add("send-header",htsdefault_sendheader);
  4907.     htswrap_add("receive-header",htsdefault_receiveheader);
  4908.   }
  4909.   
  4910.   hts_dgb("initializing SSL");    /* debug */
  4911. #if HTS_USEOPENSSL
  4912.   /*
  4913.   Initialize the OpensSSL library
  4914.   */
  4915.   if (!openssl_ctx && SSL_is_available) {
  4916.     if (SSL_load_error_strings) SSL_load_error_strings();
  4917.     SSL_library_init();
  4918.     ///if (SSL_load_error_strings)  SSL_load_error_strings();
  4919.     //if (ERR_load_crypto_strings) ERR_load_crypto_strings();
  4920.     // if (ERR_load_SSL_strings)    ERR_load_SSL_strings(); ???!!!
  4921.     // OpenSSL_add_all_algorithms();
  4922.     openssl_ctx = SSL_CTX_new(SSLv23_client_method());
  4923.     if (!openssl_ctx) {
  4924.       fprintf(stderr, "fatal: unable to initialize TLS: SSL_CTX_new(SSLv23_client_method)\n");
  4925.       abortLog("unable to initialize TLS: SSL_CTX_new(SSLv23_client_method)");
  4926.       assertf("unable to initialize TLS" == NULL);
  4927.     }
  4928.   }
  4929. #endif
  4930.   
  4931.   /* Init vars and thread-specific values */
  4932.   hts_dgb("initializing variables");    /* debug */
  4933.   hts_initvar();
  4934.   
  4935.   /* initialiser structcheck */
  4936.   // structcheck_init(1);
  4937.  
  4938.   hts_dgb("ending hts_init()");    /* debug */
  4939.   return 1;
  4940. }
  4941. HTSEXT_API int hts_uninit(void) {
  4942.   //htsthread_uninit();
  4943.   hts_cache_free(_hts_cache());
  4944.   hts_freevar();
  4945.   /* htswrap_free(); */
  4946.   return 1;
  4947. }
  4948.  
  4949. // defaut wrappers
  4950. void __cdecl htsdefault_init(void) {
  4951. }
  4952. void __cdecl htsdefault_uninit(void) {
  4953.   hts_freevar();
  4954. }
  4955. int __cdecl htsdefault_start(void* opt) {
  4956.   return 1; 
  4957. }
  4958. int __cdecl htsdefault_chopt(void* opt) {
  4959.   return 1;
  4960. }
  4961. int  __cdecl htsdefault_end(void) { 
  4962.   return 1; 
  4963. }
  4964. int __cdecl htsdefault_preprocesshtml(char** html,int* len,char* url_adresse,char* url_fichier) {
  4965.   return 1;
  4966. }
  4967. int __cdecl htsdefault_postprocesshtml(char** html,int* len,char* url_adresse,char* url_fichier) {
  4968.   return 1;
  4969. }
  4970. int __cdecl htsdefault_checkhtml(char* html,int len,char* url_adresse,char* url_fichier) {
  4971.   return 1;
  4972. }
  4973. int __cdecl htsdefault_loop(void* back,int back_max,int back_index,int lien_n,int lien_tot,int stat_time,hts_stat_struct* stats) {    // appelΘ α chaque boucle de HTTrack
  4974.   return 1;
  4975. }
  4976. char* __cdecl htsdefault_query(char* question) {
  4977.   return "";
  4978. }
  4979. char* __cdecl htsdefault_query2(char* question) {
  4980.   return "";
  4981. }
  4982. char* __cdecl htsdefault_query3(char* question) {
  4983.   return "";
  4984. }
  4985. int __cdecl htsdefault_check(char* adr,char* fil,int status) {
  4986.   return -1;
  4987. }
  4988. void __cdecl htsdefault_pause(char* lockfile) {
  4989.   while (fexist(lockfile)) {
  4990.     Sleep(1000);
  4991.   }
  4992. }
  4993. void __cdecl htsdefault_filesave(char* file) {
  4994. }
  4995. int __cdecl htsdefault_linkdetected(char* link) {
  4996.   return 1;
  4997. }
  4998. int __cdecl htsdefault_linkdetected2(char* link, char* start_tag) {
  4999.   return 1;
  5000. }
  5001. int __cdecl htsdefault_xfrstatus(void* back) {
  5002.   return 1;
  5003. }
  5004. int __cdecl htsdefault_savename(char* adr_complete,char* fil_complete,char* referer_adr,char* referer_fil,char* save) {
  5005.   return 1;
  5006. }
  5007. int __cdecl htsdefault_sendheader(char* buff, char* adr, char* fil, char* referer_adr, char* referer_fil, htsblk* outgoing) {
  5008.   return 1;
  5009. }
  5010. int __cdecl htsdefault_receiveheader(char* buff, char* adr, char* fil, char* referer_adr, char* referer_fil, htsblk* incoming) {
  5011.   return 1;
  5012. }
  5013. // end defaut wrappers
  5014.  
  5015.  
  5016.  
  5017. // Fin
  5018.  
  5019.